(sys_signal): Undo previous change.
[bpt/emacs.git] / src / lisp.h
CommitLineData
3cfe6dfd 1/* Fundamental definitions for GNU Emacs Lisp interpreter.
2f69f2ec 2 Copyright (C) 1985,86,87,93,94,95, 1997 Free Software Foundation, Inc.
3cfe6dfd
JB
3
4This file is part of GNU Emacs.
5
6GNU Emacs is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
4746118a 8the Free Software Foundation; either version 2, or (at your option)
3cfe6dfd
JB
9any later version.
10
11GNU Emacs is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Emacs; see the file COPYING. If not, write to
3b7ad313
EN
18the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
3cfe6dfd
JB
20
21
ce99fd65
RS
22/* These are default choices for the types to use. */
23#ifndef EMACS_INT
24#define EMACS_INT int
1747fb16 25#define BITS_PER_EMACS_INT BITS_PER_INT
ce99fd65
RS
26#endif
27#ifndef EMACS_UINT
28#define EMACS_UINT unsigned int
29#endif
30
99a3d506 31/* Define the fundamental Lisp data structures. */
3cfe6dfd 32
99a3d506 33/* This is the set of Lisp data types. */
3cfe6dfd
JB
34
35enum Lisp_Type
36 {
99a3d506 37 /* Integer. XINT (obj) is the integer value. */
3cfe6dfd
JB
38 Lisp_Int,
39
99a3d506 40 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
3cfe6dfd
JB
41 Lisp_Symbol,
42
84d1833e
KH
43 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
44 whose first member indicates the subtype. */
45 Lisp_Misc,
3cfe6dfd
JB
46
47 /* String. XSTRING (object) points to a struct Lisp_String.
99a3d506 48 The length of the string, and its contents, are stored therein. */
3cfe6dfd
JB
49 Lisp_String,
50
b5088f80 51 /* Vector of Lisp objects, or something resembling it.
7c06ac2b 52 XVECTOR (object) points to a struct Lisp_Vector, which contains
b5088f80
KH
53 the size and contents. The size field also contains the type
54 information, if it's not a real vector object. */
55 Lisp_Vectorlike,
3cfe6dfd 56
99a3d506 57 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
3cfe6dfd
JB
58 Lisp_Cons,
59
3cfe6dfd 60#ifdef LISP_FLOAT_TYPE
20280af7 61 Lisp_Float,
3cfe6dfd 62#endif /* LISP_FLOAT_TYPE */
4d1207f6
RS
63
64 /* This is not a type code. It is for range checking. */
e2ba196c 65 Lisp_Type_Limit
3cfe6dfd
JB
66 };
67
84d1833e 68/* This is the set of datatypes that share a common structure.
c98adc1b
KH
69 The first member of the structure is a type code from this set.
70 The enum values are arbitrary, but we'll use large numbers to make it
71 more likely that we'll spot the error if a random word in memory is
72 mistakenly interpreted as a Lisp_Misc. */
1c4ca5a3
KH
73enum Lisp_Misc_Type
74 {
c98adc1b 75 Lisp_Misc_Free = 0x5eab,
84d1833e 76 Lisp_Misc_Marker,
ee4c9ce4
KH
77 Lisp_Misc_Intfwd,
78 Lisp_Misc_Boolfwd,
79 Lisp_Misc_Objfwd,
7d65f1c2
KH
80 Lisp_Misc_Buffer_Objfwd,
81 Lisp_Misc_Buffer_Local_Value,
ce7d8eec 82 Lisp_Misc_Some_Buffer_Local_Value,
99a3d506 83 Lisp_Misc_Overlay,
32462604 84 Lisp_Misc_Kboard_Objfwd,
99a3d506
RS
85 /* Currently floats are not a misc type,
86 but let's define this in case we want to change that. */
87 Lisp_Misc_Float,
88 /* This is not a type code. It is for range checking. */
89 Lisp_Misc_Limit
1c4ca5a3
KH
90 };
91
e2ba196c
KH
92/* These values are overridden by the m- file on some machines. */
93#ifndef VALBITS
94#define VALBITS 28
95#endif
96
97#ifndef GCTYPEBITS
98#define GCTYPEBITS 3
99#endif
100
c9ddd39d
KH
101/* Make these values available in GDB, which sees enums but not macros. */
102
103enum gdb_lisp_params
104{
105 gdb_valbits = VALBITS,
106 gdb_gctypebits = GCTYPEBITS,
68be917d 107 gdb_emacs_intbits = sizeof (EMACS_INT) * BITS_PER_CHAR,
c9ddd39d
KH
108#ifdef DATA_SEG_BITS
109 gdb_data_seg_bits = DATA_SEG_BITS
110#else
111 gdb_data_seg_bits = 0
112#endif
113};
114
3cfe6dfd
JB
115#ifndef NO_UNION_TYPE
116
c451d7b1 117#ifndef WORDS_BIG_ENDIAN
3cfe6dfd
JB
118
119/* Definition of Lisp_Object for little-endian machines. */
120
121typedef
122union Lisp_Object
123 {
124 /* Used for comparing two Lisp_Objects;
99a3d506 125 also, positive integers can be accessed fast this way. */
3cfe6dfd
JB
126 int i;
127
128 struct
129 {
e2ba196c
KH
130 int val: VALBITS;
131 int type: GCTYPEBITS+1;
3cfe6dfd
JB
132 } s;
133 struct
134 {
e2ba196c
KH
135 unsigned int val: VALBITS;
136 int type: GCTYPEBITS+1;
3cfe6dfd
JB
137 } u;
138 struct
139 {
e2ba196c
KH
140 unsigned int val: VALBITS;
141 enum Lisp_Type type: GCTYPEBITS;
3cfe6dfd
JB
142 /* The markbit is not really part of the value of a Lisp_Object,
143 and is always zero except during garbage collection. */
144 unsigned int markbit: 1;
145 } gu;
146 }
147Lisp_Object;
148
c451d7b1 149#else /* If WORDS_BIG_ENDIAN */
3cfe6dfd
JB
150
151typedef
152union Lisp_Object
153 {
154 /* Used for comparing two Lisp_Objects;
99a3d506 155 also, positive integers can be accessed fast this way. */
3cfe6dfd
JB
156 int i;
157
158 struct
159 {
e2ba196c
KH
160 int type: GCTYPEBITS+1;
161 int val: VALBITS;
3cfe6dfd
JB
162 } s;
163 struct
164 {
e2ba196c
KH
165 int type: GCTYPEBITS+1;
166 unsigned int val: VALBITS;
3cfe6dfd
JB
167 } u;
168 struct
169 {
170 /* The markbit is not really part of the value of a Lisp_Object,
171 and is always zero except during garbage collection. */
172 unsigned int markbit: 1;
e2ba196c
KH
173 enum Lisp_Type type: GCTYPEBITS;
174 unsigned int val: VALBITS;
3cfe6dfd
JB
175 } gu;
176 }
177Lisp_Object;
178
c451d7b1 179#endif /* WORDS_BIG_ENDIAN */
3cfe6dfd
JB
180
181#endif /* NO_UNION_TYPE */
182
183
1c5ca8b6 184/* If union type is not wanted, define Lisp_Object as just a number. */
3cfe6dfd
JB
185
186#ifdef NO_UNION_TYPE
627a9502 187#define Lisp_Object EMACS_INT
1c5ca8b6 188#endif /* NO_UNION_TYPE */
3cfe6dfd 189
3cfe6dfd 190#ifndef VALMASK
627a9502 191#define VALMASK ((((EMACS_INT) 1)<<VALBITS) - 1)
3cfe6dfd 192#endif
627a9502 193#define GCTYPEMASK ((((EMACS_INT) 1)<<GCTYPEBITS) - 1)
846d69ac
RS
194
195/* Two flags that are set during GC. On some machines, these flags
196 are defined differently by the m- file. */
197
198/* This is set in the car of a cons and in the plist slot of a symbol
199 to indicate it is marked. Likewise in the plist slot of an interval,
200 the chain slot of a marker, the type slot of a float, and the name
201 slot of a buffer.
202
203 In strings, this bit in the size field indicates that the string
204 is a "large" one, one which was separately malloc'd
205 rather than being part of a string block. */
206
627a9502 207#ifndef MARKBIT
8ce6977e 208#define MARKBIT ((int) ((unsigned int) 1 << (VALBITS + GCTYPEBITS)))
627a9502 209#endif /*MARKBIT */
3cfe6dfd 210
846d69ac
RS
211/* In the size word of a vector, this bit means the vector has been marked.
212 In the size word of a large string, likewise. */
213
214#ifndef ARRAY_MARK_FLAG
215#define ARRAY_MARK_FLAG ((MARKBIT >> 1) & ~MARKBIT)
216#endif /* no ARRAY_MARK_FLAG */
217
b5088f80
KH
218/* In the size word of a struct Lisp_Vector, this bit means it's really
219 some other vector-like object. */
220#ifndef PSEUDOVECTOR_FLAG
221#define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1) & ~ARRAY_MARK_FLAG)
222#endif
223
303a5c93 224/* In a pseudovector, the size field actually contains a word with one
b5088f80
KH
225 PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
226 indicate the actual type. */
99a3d506
RS
227enum pvec_type
228{
229 PVEC_NORMAL_VECTOR = 0,
99a3d506
RS
230 PVEC_PROCESS = 0x200,
231 PVEC_FRAME = 0x400,
232 PVEC_COMPILED = 0x800,
233 PVEC_WINDOW = 0x1000,
234 PVEC_WINDOW_CONFIGURATION = 0x2000,
235 PVEC_SUBR = 0x4000,
608ff985
RS
236 PVEC_CHAR_TABLE = 0x8000,
237 PVEC_BOOL_VECTOR = 0x10000,
238 PVEC_BUFFER = 0x20000,
782dad44 239 PVEC_TYPE_MASK = 0x3fe00,
e3d48049 240 PVEC_FLAG = PSEUDOVECTOR_FLAG
99a3d506 241};
b5088f80
KH
242
243/* For convenience, we also store the number of elements in these bits. */
608ff985 244#define PSEUDOVECTOR_SIZE_MASK 0x1ff
3cfe6dfd
JB
245\f
246/* These macros extract various sorts of values from a Lisp_Object.
247 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
99a3d506 248 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
3cfe6dfd
JB
249
250#ifdef NO_UNION_TYPE
251
252/* One need to override this if there must be high bits set in data space
253 (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
254 on all machines, but would penalise machines which don't need it)
255 */
256#ifndef XTYPE
257#define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
258#endif
259
260#ifndef XSETTYPE
627a9502 261#define XSETTYPE(a, b) ((a) = XUINT (a) | ((EMACS_INT)(b) << VALBITS))
3cfe6dfd
JB
262#endif
263
221f4ef3
KH
264/* For integers known to be positive, XFASTINT provides fast retrieval
265 and XSETFASTINT provides fast storage. This takes advantage of the
266 fact that Lisp_Int is 0. */
e43ec785 267#define XFASTINT(a) ((a) + 0)
221f4ef3 268#define XSETFASTINT(a, b) ((a) = (b))
3cfe6dfd
JB
269
270/* Extract the value of a Lisp_Object as a signed integer. */
271
272#ifndef XINT /* Some machines need to do this differently. */
68be917d 273#define XINT(a) (((a) << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
3cfe6dfd
JB
274#endif
275
276/* Extract the value as an unsigned integer. This is a basis
277 for extracting it as a pointer to a structure in storage. */
278
279#ifndef XUINT
280#define XUINT(a) ((a) & VALMASK)
281#endif
282
283#ifndef XPNTR
284#ifdef HAVE_SHM
285/* In this representation, data is found in two widely separated segments. */
29eab336 286extern int pure_size;
3cfe6dfd 287#define XPNTR(a) \
29eab336 288 (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
3cfe6dfd
JB
289#else /* not HAVE_SHM */
290#ifdef DATA_SEG_BITS
291/* This case is used for the rt-pc.
292 In the diffs I was given, it checked for ptr = 0
293 and did not adjust it in that case.
294 But I don't think that zero should ever be found
295 in a Lisp object whose data type says it points to something. */
296#define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
297#else
298#define XPNTR(a) XUINT (a)
299#endif
300#endif /* not HAVE_SHM */
301#endif /* no XPNTR */
302
3cfe6dfd
JB
303#ifndef XSET
304#define XSET(var, type, ptr) \
627a9502 305 ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
3cfe6dfd
JB
306#endif
307
b7acde90
KH
308/* Convert a C integer into a Lisp_Object integer. */
309
310#define make_number(N) \
311 ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
312
3cfe6dfd
JB
313/* During garbage collection, XGCTYPE must be used for extracting types
314 so that the mark bit is ignored. XMARKBIT accesses the markbit.
315 Markbits are used only in particular slots of particular structure types.
316 Other markbits are always zero.
317 Outside of garbage collection, all mark bits are always zero. */
318
319#ifndef XGCTYPE
320#define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK))
321#endif
322
1747fb16 323#if VALBITS + GCTYPEBITS == BITS_PER_EMACS_INT - 1
3cfe6dfd
JB
324/* Make XMARKBIT faster if mark bit is sign bit. */
325#ifndef XMARKBIT
326#define XMARKBIT(a) ((a) < 0)
327#endif
328#endif /* markbit is sign bit */
329
330#ifndef XMARKBIT
331#define XMARKBIT(a) ((a) & MARKBIT)
332#endif
333
334#ifndef XSETMARKBIT
335#define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) | ((b) ? MARKBIT : 0))
336#endif
337
338#ifndef XMARK
339#define XMARK(a) ((a) |= MARKBIT)
340#endif
341
342#ifndef XUNMARK
343#define XUNMARK(a) ((a) &= ~MARKBIT)
344#endif
345
346#endif /* NO_UNION_TYPE */
347
348#ifndef NO_UNION_TYPE
349
350#define XTYPE(a) ((enum Lisp_Type) (a).u.type)
351#define XSETTYPE(a, b) ((a).u.type = (char) (b))
352
221f4ef3
KH
353/* For integers known to be positive, XFASTINT provides fast retrieval
354 and XSETFASTINT provides fast storage. This takes advantage of the
355 fact that Lisp_Int is 0. */
e43ec785 356#define XFASTINT(a) ((a).i + 0)
221f4ef3 357#define XSETFASTINT(a, b) ((a).i = (b))
3cfe6dfd
JB
358
359#ifdef EXPLICIT_SIGN_EXTEND
360/* Make sure we sign-extend; compilers have been known to fail to do so. */
68be917d 361#define XINT(a) (((a).i << (BITS_PER_INT-VALBITS)) >> (BITS_PER_INT-VALBITS))
3cfe6dfd
JB
362#else
363#define XINT(a) ((a).s.val)
364#endif /* EXPLICIT_SIGN_EXTEND */
365
366#define XUINT(a) ((a).u.val)
367#define XPNTR(a) ((a).u.val)
3cfe6dfd
JB
368
369#define XSET(var, vartype, ptr) \
370 (((var).s.type = ((char) (vartype))), ((var).s.val = ((int) (ptr))))
371
e98227af
KH
372extern Lisp_Object make_number ();
373
3cfe6dfd
JB
374/* During garbage collection, XGCTYPE must be used for extracting types
375 so that the mark bit is ignored. XMARKBIT access the markbit.
376 Markbits are used only in particular slots of particular structure types.
377 Other markbits are always zero.
378 Outside of garbage collection, all mark bits are always zero. */
379
380#define XGCTYPE(a) ((a).gu.type)
381#define XMARKBIT(a) ((a).gu.markbit)
382#define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
383#define XMARK(a) (XMARKBIT(a) = 1)
384#define XUNMARK(a) (XMARKBIT(a) = 0)
385
386#endif /* NO_UNION_TYPE */
387
99a3d506 388/* Extract a value or address from a Lisp_Object. */
3cfe6dfd
JB
389
390#define XCONS(a) ((struct Lisp_Cons *) XPNTR(a))
3cfe6dfd 391#define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
3cfe6dfd
JB
392#define XSTRING(a) ((struct Lisp_String *) XPNTR(a))
393#define XSYMBOL(a) ((struct Lisp_Symbol *) XPNTR(a))
3cfe6dfd 394#define XFLOAT(a) ((struct Lisp_Float *) XPNTR(a))
7c06ac2b
RS
395
396/* Misc types. */
397#define XMISC(a) ((union Lisp_Misc *) XPNTR(a))
a7aa28f6 398#define XMISCTYPE(a) (XMARKER (a)->type)
84d1833e 399#define XMARKER(a) (&(XMISC(a)->u_marker))
ee4c9ce4
KH
400#define XINTFWD(a) (&(XMISC(a)->u_intfwd))
401#define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
402#define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
403#define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
7d65f1c2 404#define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
ce7d8eec 405#define XOVERLAY(a) (&(XMISC(a)->u_overlay))
32462604 406#define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
3cfe6dfd 407
7c06ac2b
RS
408/* Pseudovector types. */
409#define XPROCESS(a) ((struct Lisp_Process *) XPNTR(a))
410#define XWINDOW(a) ((struct window *) XPNTR(a))
411#define XSUBR(a) ((struct Lisp_Subr *) XPNTR(a))
99a3d506 412#define XBUFFER(a) ((struct buffer *) XPNTR(a))
608ff985
RS
413#define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
414#define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
99a3d506
RS
415
416
417/* Construct a Lisp_Object from a value or address. */
7c06ac2b 418
a94ef819
KH
419#define XSETINT(a, b) XSET (a, Lisp_Int, b)
420#define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
b5088f80 421#define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
a94ef819
KH
422#define XSETSTRING(a, b) XSET (a, Lisp_String, b)
423#define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
a94ef819 424#define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
7c06ac2b
RS
425
426/* Misc types. */
427#define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
a7aa28f6 428#define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
7c06ac2b
RS
429
430/* Pseudovector types. */
431#define XSETPSEUDOVECTOR(a, b, code) \
432 (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
433#define XSETWINDOW_CONFIGURATION(a, b) \
434 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
435#define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
436#define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
437#define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
438#define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
99a3d506 439#define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
608ff985
RS
440#define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
441#define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
3cfe6dfd 442\f
e221eae3 443#ifdef USE_TEXT_PROPERTIES
99a3d506 444/* Basic data type for use of intervals. See the macros in intervals.h. */
e221eae3
JA
445
446struct interval
447{
99a3d506 448 /* The first group of entries deal with the tree structure. */
e221eae3 449
99a3d506
RS
450 unsigned int total_length; /* Length of myself and both children. */
451 unsigned int position; /* Cache of interval's character position. */
452 struct interval *left; /* Intervals which precede me. */
453 struct interval *right; /* Intervals which succeed me. */
e8720644
JB
454
455 /* Parent in the tree, or the Lisp_Object containing this interval tree.
456
457 The mark bit on the root interval of an interval tree says
458 whether we have started (and possibly finished) marking the
459 tree. If GC comes across an interval tree whose root's parent
460 field has its markbit set, it leaves the tree alone.
461
462 You'd think we could store this information in the parent object
463 somewhere (after all, that should be visited once and then
464 ignored too, right?), but strings are GC'd strangely. */
465 struct interval *parent;
e221eae3
JA
466
467 /* The remaining components are `properties' of the interval.
468 The first four are duplicates for things which can be on the list,
99a3d506 469 for purposes of speed. */
e221eae3
JA
470
471 unsigned char write_protect; /* Non-zero means can't modify. */
99a3d506 472 unsigned char visible; /* Zero means don't display. */
cde20f41 473 unsigned char front_sticky; /* Non-zero means text inserted just
99a3d506
RS
474 before this interval goes into it. */
475 unsigned char rear_sticky; /* Likewise for just after it. */
e221eae3 476
e8720644
JB
477 /* Properties of this interval.
478 The mark bit on this field says whether this particular interval
479 tree node has been visited. Since intervals should never be
480 shared, GC aborts if it seems to have visited an interval twice. */
481 Lisp_Object plist;
e221eae3
JA
482};
483
484typedef struct interval *INTERVAL;
485
486/* Complain if object is not string or buffer type */
487#define CHECK_STRING_OR_BUFFER(x, i) \
c5af3bb9 488 { if (!STRINGP ((x)) && !BUFFERP ((x))) \
e221eae3
JA
489 x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
490
491/* Macro used to conditionally compile intervals into certain data
99a3d506 492 structures. See, e.g., struct Lisp_String below. */
e221eae3
JA
493#define DECLARE_INTERVALS INTERVAL intervals;
494
eb8c3be9 495/* Macro used to conditionally compile interval initialization into
99a3d506 496 certain code. See, e.g., alloc.c. */
e221eae3
JA
497#define INITIALIZE_INTERVAL(ptr,val) ptr->intervals = val
498
499#else /* No text properties */
500
99a3d506 501/* If no intervals are used, make the above definitions go away. */
e221eae3
JA
502
503#define CHECK_STRING_OR_BUFFER(x, i)
504
505#define INTERVAL
506#define DECLARE_INTERVALS
507#define INITIALIZE_INTERVAL(ptr,val)
508
509#endif /* USE_TEXT_PROPERTIES */
510\f
3cfe6dfd
JB
511/* In a cons, the markbit of the car is the gc mark bit */
512
513struct Lisp_Cons
514 {
515 Lisp_Object car, cdr;
516 };
517
b7acde90
KH
518/* Take the car or cdr of something known to be a cons cell. */
519#define XCAR(c) (XCONS ((c))->car)
520#define XCDR(c) (XCONS ((c))->cdr)
521
522/* Take the car or cdr of something whose type is not known. */
523#define CAR(c) \
524 (CONSP ((c)) ? XCAR ((c)) \
525 : NILP ((c)) ? Qnil \
526 : wrong_type_argument (Qlistp, (c)))
527
528#define CDR(c) \
529 (CONSP ((c)) ? XCDR ((c)) \
530 : NILP ((c)) ? Qnil \
531 : wrong_type_argument (Qlistp, (c)))
532
3cfe6dfd
JB
533/* Like a cons, but records info on where the text lives that it was read from */
534/* This is not really in use now */
535
536struct Lisp_Buffer_Cons
537 {
538 Lisp_Object car, cdr;
539 struct buffer *buffer;
540 int bufpos;
541 };
542
543/* In a string or vector, the sign bit of the `size' is the gc mark bit */
544
545struct Lisp_String
546 {
627a9502 547 EMACS_INT size;
99a3d506 548 DECLARE_INTERVALS /* `data' field must be last. */
3cfe6dfd
JB
549 unsigned char data[1];
550 };
551
94225242 552/* If a struct is made to look like a vector, this macro returns the length
4115d3f7
RS
553 of the shortest vector that would hold that struct. */
554#define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector) \
555 - sizeof (Lisp_Object)) \
556 + sizeof(Lisp_Object) - 1) /* round up */ \
94225242
KH
557 / sizeof (Lisp_Object))
558
3cfe6dfd
JB
559struct Lisp_Vector
560 {
627a9502 561 EMACS_INT size;
3cfe6dfd
JB
562 struct Lisp_Vector *next;
563 Lisp_Object contents[1];
564 };
565
ea724a01
KH
566/* A char table is a kind of vectorlike, with contents are like a
567 vector but with a few other slots. For some purposes, it makes
568 sense to handle a chartable with type struct Lisp_Vector. An
569 element of a char table can be any Lisp objects, but if it is a sub
570 char-table, we treat it a table that contains information of a
571 group of characters of the same charsets or a specific character of
572 a charset. A sub char-table has the same structure as a char table
573 except for that the former omits several slots at the tail. A sub
574 char table appears only in an element of a char table, and there's
575 no way to access it directly from Emacs Lisp program. */
e98227af 576
b96656ce
KH
577/* This is the number of slots that apply to characters or character
578 sets. The first 128 are for ASCII, the next 128 are for 8-bit
ea724a01
KH
579 European characters, and the last 128 are for multibyte characters.
580 The first 256 are indexed by the code itself, but the last 128 are
581 indexed by (charset-id + 128). */
b96656ce
KH
582#define CHAR_TABLE_ORDINARY_SLOTS 384
583
584/* This is the number of slots that apply to characters of ASCII and
585 8-bit Europeans only. */
586#define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
608ff985 587
ea724a01
KH
588/* This is the number of slots that every char table must have. This
589 counts the ordinary slots and the top, defalt, parent, and purpose
590 slots. */
591#define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
592
593/* This is the number of slots that apply to position-code-1 and
594 position-code-2 of a multibyte character at the 2nd and 3rd level
595 sub char tables respectively. */
596#define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
597
598/* This is the number of slots that every sub char table must have.
599 This counts the ordinary slots and the top and defalt slot. */
e98227af 600#define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
608ff985
RS
601
602/* Return the number of "extra" slots in the char table CT. */
603
604#define CHAR_TABLE_EXTRA_SLOTS(CT) \
605 (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
606
b96656ce 607/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
8ac90470
KH
608 and 8-bit Europeans characters. For these characters, do not check
609 validity of CT. Do not follow parent. */
610#define CHAR_TABLE_REF(CT, IDX) \
2e34157c
RS
611 ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
612 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
613 ? XCHAR_TABLE (CT)->contents[IDX] \
8ac90470 614 : XCHAR_TABLE (CT)->defalt) \
2e34157c 615 : Faref (CT, make_number (IDX)))
b96656ce
KH
616
617/* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
8ac90470
KH
618 8-bit Europeans characters. Do not check validity of CT. */
619#define CHAR_TABLE_SET(CT, IDX, VAL) \
620 do { \
621 if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
622 XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
623 else \
624 Faset (CT, IDX, VAL); \
b96656ce
KH
625 } while (0)
626
608ff985
RS
627struct Lisp_Char_Table
628 {
629 /* This is the vector's size field, which also holds the
630 pseudovector type information. It holds the size, too.
ea724a01
KH
631 The size counts the top, defalt, purpose, and parent slots.
632 The last three are not counted if this is a sub char table. */
608ff985
RS
633 EMACS_INT size;
634 struct Lisp_Vector *next;
ea724a01
KH
635 /* This holds a flag to tell if this is a top level char table (t)
636 or a sub char table (nil). */
637 Lisp_Object top;
608ff985
RS
638 /* This holds a default value,
639 which is used whenever the value for a specific character is nil. */
640 Lisp_Object defalt;
ea724a01
KH
641 /* This holds an actual value of each element. A sub char table
642 has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements. */
643 Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
644
645 /* A sub char table doesn't has the following slots. */
646
608ff985
RS
647 /* This points to another char table, which we inherit from
648 when the value for a specific character is nil.
649 The `defalt' slot takes precedence over this. */
650 Lisp_Object parent;
7f73dc9d
RS
651 /* This should be a symbol which says what kind of use
652 this char-table is meant for.
653 Typically now the values can be `syntax-table' and `display-table'. */
654 Lisp_Object purpose;
608ff985
RS
655 /* These hold additional data. */
656 Lisp_Object extras[1];
657 };
658
659/* A boolvector is a kind of vectorlike, with contents are like a string. */
660struct Lisp_Bool_Vector
661 {
662 /* This is the vector's size field. It doesn't have the real size,
663 just the subtype information. */
664 EMACS_INT vector_size;
665 struct Lisp_Vector *next;
666 /* This is the size in bits. */
667 EMACS_INT size;
668 /* This contains the actual bits, packed into bytes. */
669 unsigned char data[1];
670 };
671
3cfe6dfd
JB
672/* In a symbol, the markbit of the plist is used as the gc mark bit */
673
674struct Lisp_Symbol
675 {
676 struct Lisp_String *name;
677 Lisp_Object value;
678 Lisp_Object function;
679 Lisp_Object plist;
92a2515a 680 Lisp_Object obarray;
3cfe6dfd
JB
681 struct Lisp_Symbol *next; /* -> next symbol in this obarray bucket */
682 };
683
7c06ac2b
RS
684/* This structure describes a built-in function.
685 It is generated by the DEFUN macro only.
686 defsubr makes it into a Lisp object.
687
688 This type is treated in most respects as a pseudovector,
689 but since we never dynamically allocate or free them,
690 we don't need a next-vector field. */
e98227af 691
3cfe6dfd
JB
692struct Lisp_Subr
693 {
7c06ac2b 694 EMACS_INT size;
3cfe6dfd
JB
695 Lisp_Object (*function) ();
696 short min_args, max_args;
697 char *symbol_name;
698 char *prompt;
699 char *doc;
700 };
ee4c9ce4 701\f
7c06ac2b
RS
702/* These structures are used for various misc types. */
703
ee4c9ce4
KH
704/* A miscellaneous object, when it's on the free list. */
705struct Lisp_Free
706 {
5bfac5a9
RS
707 int type : 16; /* = Lisp_Misc_Free */
708 int spacer : 16;
ee4c9ce4
KH
709 union Lisp_Misc *chain;
710 };
3cfe6dfd 711
609c36fe 712/* In a marker, the markbit of the chain field is used as the gc mark bit. */
3cfe6dfd 713struct Lisp_Marker
308e97d0
RS
714{
715 int type : 16; /* = Lisp_Misc_Marker */
716 int spacer : 15;
717 /* 1 means normal insertion at the marker's position
718 leaves the marker after the inserted text. */
719 unsigned int insertion_type : 1;
720 struct buffer *buffer;
721 Lisp_Object chain;
722 int bufpos;
723};
3cfe6dfd 724
ee4c9ce4
KH
725/* Forwarding pointer to an int variable.
726 This is allowed only in the value cell of a symbol,
727 and it means that the symbol's value really lives in the
728 specified int variable. */
729struct Lisp_Intfwd
84d1833e 730 {
5bfac5a9
RS
731 int type : 16; /* = Lisp_Misc_Intfwd */
732 int spacer : 16;
ee4c9ce4
KH
733 int *intvar;
734 };
735
736/* Boolean forwarding pointer to an int variable.
737 This is like Lisp_Intfwd except that the ostensible
738 "value" of the symbol is t if the int variable is nonzero,
739 nil if it is zero. */
740struct Lisp_Boolfwd
741 {
5bfac5a9
RS
742 int type : 16; /* = Lisp_Misc_Boolfwd */
743 int spacer : 16;
ee4c9ce4
KH
744 int *boolvar;
745 };
746
747/* Forwarding pointer to a Lisp_Object variable.
748 This is allowed only in the value cell of a symbol,
749 and it means that the symbol's value really lives in the
750 specified variable. */
751struct Lisp_Objfwd
752 {
5bfac5a9
RS
753 int type : 16; /* = Lisp_Misc_Objfwd */
754 int spacer : 16;
ee4c9ce4
KH
755 Lisp_Object *objvar;
756 };
757
758/* Like Lisp_Objfwd except that value lives in a slot in the
759 current buffer. Value is byte index of slot within buffer. */
760struct Lisp_Buffer_Objfwd
761 {
5bfac5a9
RS
762 int type : 16; /* = Lisp_Misc_Buffer_Objfwd */
763 int spacer : 16;
ee4c9ce4 764 int offset;
84d1833e
KH
765 };
766
7d65f1c2
KH
767/* Used in a symbol value cell when the symbol's value is per-buffer.
768 The actual contents resemble a cons cell which starts a list like this:
769 (REALVALUE BUFFER CURRENT-ALIST-ELEMENT . DEFAULT-VALUE).
770
ce7d8eec
KH
771 The cons-like structure is for historical reasons; it might be better
772 to just put these elements into the struct, now.
773
7d65f1c2
KH
774 BUFFER is the last buffer for which this symbol's value was
775 made up to date.
776
777 CURRENT-ALIST-ELEMENT is a pointer to an element of BUFFER's
778 local_var_alist, that being the element whose car is this
779 variable. Or it can be a pointer to the
780 (CURRENT-ALIST-ELEMENT . DEFAULT-VALUE),
781 if BUFFER does not have an element in its alist for this
782 variable (that is, if BUFFER sees the default value of this
783 variable).
784
785 If we want to examine or set the value and BUFFER is current,
99a3d506 786 we just examine or set REALVALUE. If BUFFER is not current, we
7d65f1c2
KH
787 store the current REALVALUE value into CURRENT-ALIST-ELEMENT,
788 then find the appropriate alist element for the buffer now
789 current and set up CURRENT-ALIST-ELEMENT. Then we set
790 REALVALUE out of that element, and store into BUFFER.
791
792 If we are setting the variable and the current buffer does not
793 have an alist entry for this variable, an alist entry is
794 created.
795
796 Note that REALVALUE can be a forwarding pointer. Each time it
797 is examined or set, forwarding must be done. Each time we
798 switch buffers, buffer-local variables which forward into C
799 variables are swapped immediately, so the C code can assume
800 that they are always up to date.
801
802 Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
803 use the same substructure. The difference is that with the latter,
804 merely setting the variable while some buffer is current
805 does not cause that buffer to have its own local value of this variable.
806 Only make-local-variable does that. */
807struct Lisp_Buffer_Local_Value
808 {
5bfac5a9
RS
809 int type : 16; /* = Lisp_Misc_Buffer_Local_Value
810 or Lisp_Misc_Some_Buffer_Local_Value */
811 int spacer : 16;
7d65f1c2
KH
812 Lisp_Object car, cdr;
813 };
814
ce7d8eec
KH
815/* In an overlay object, the mark bit of the plist is used as the GC mark.
816 START and END are markers in the overlay's buffer, and
817 PLIST is the overlay's property list. */
818struct Lisp_Overlay
819 {
5bfac5a9
RS
820 int type : 16; /* = Lisp_Misc_Overlay */
821 int spacer : 16;
ce7d8eec
KH
822 Lisp_Object start, end, plist;
823 };
5bfac5a9 824
f334de0e 825/* Like Lisp_Objfwd except that value lives in a slot in the
32462604
KH
826 current kboard. */
827struct Lisp_Kboard_Objfwd
f334de0e 828 {
32462604 829 int type : 16; /* = Lisp_Misc_Kboard_Objfwd */
f334de0e
KH
830 int spacer : 16;
831 int offset;
832 };
833
5bfac5a9 834
a7aa28f6
RS
835/* To get the type field of a union Lisp_Misc, use XMISCTYPE.
836 It uses one of these struct subtypes to get the type field. */
837
84d1833e
KH
838union Lisp_Misc
839 {
84d1833e
KH
840 struct Lisp_Free u_free;
841 struct Lisp_Marker u_marker;
ee4c9ce4
KH
842 struct Lisp_Intfwd u_intfwd;
843 struct Lisp_Boolfwd u_boolfwd;
844 struct Lisp_Objfwd u_objfwd;
845 struct Lisp_Buffer_Objfwd u_buffer_objfwd;
7d65f1c2 846 struct Lisp_Buffer_Local_Value u_buffer_local_value;
ce7d8eec 847 struct Lisp_Overlay u_overlay;
32462604 848 struct Lisp_Kboard_Objfwd u_kboard_objfwd;
84d1833e 849 };
7c06ac2b 850\f
3cfe6dfd
JB
851#ifdef LISP_FLOAT_TYPE
852/* Optional Lisp floating point type */
853struct Lisp_Float
854 {
e98227af 855 Lisp_Object type; /* essentially used for mark-bit
3cfe6dfd 856 and chaining when on free-list */
e98227af 857 double data;
3cfe6dfd
JB
858 };
859#endif /* LISP_FLOAT_TYPE */
860
861/* A character, declared with the following typedef, is a member
99a3d506 862 of some character set associated with the current buffer. */
b2ba7b00
RS
863#ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
864#define _UCHAR_T
3cfe6dfd 865typedef unsigned char UCHAR;
b2ba7b00 866#endif
3cfe6dfd
JB
867
868/* Meanings of slots in a Lisp_Compiled: */
869
870#define COMPILED_ARGLIST 0
871#define COMPILED_BYTECODE 1
872#define COMPILED_CONSTANTS 2
873#define COMPILED_STACK_DEPTH 3
874#define COMPILED_DOC_STRING 4
875#define COMPILED_INTERACTIVE 5
88dbfee5 876
d03f79ef
JB
877/* Flag bits in a character. These also get used in termhooks.h.
878 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
7c06ac2b
RS
879 (MUlti-Lingual Emacs) might need 22 bits for the character value
880 itself, so we probably shouldn't use any bits lower than 0x0400000. */
881#define CHAR_ALT (0x0400000)
882#define CHAR_SUPER (0x0800000)
883#define CHAR_HYPER (0x1000000)
884#define CHAR_SHIFT (0x2000000)
885#define CHAR_CTL (0x4000000)
886#define CHAR_META (0x8000000)
703f2808 887
6b768554
KH
888/* Actually, the current Emacs uses 19 bits for the character value
889 itself. */
890#define CHARACTERBITS 19
891
e6faba7f
RS
892#ifdef USE_X_TOOLKIT
893#ifdef NO_UNION_TYPE
894/* Use this for turning a (void *) into a Lisp_Object, as when the
895 Lisp_Object is passed into a toolkit callback function. */
896#define VOID_TO_LISP(larg,varg) \
897 do { ((larg) = ((Lisp_Object) (varg))); } while (0)
898#define CVOID_TO_LISP VOID_TO_LISP
899
900/* Use this for turning a Lisp_Object into a (void *), as when the
901 Lisp_Object is passed into a toolkit callback function. */
902#define LISP_TO_VOID(larg) ((void *) (larg))
903#define LISP_TO_CVOID(varg) ((const void *) (larg))
904
905#else /* not NO_UNION_TYPE */
906/* Use this for turning a (void *) into a Lisp_Object, as when the
907 Lisp_Object is passed into a toolkit callback function. */
908#define VOID_TO_LISP(larg,varg) \
909 do { ((larg).v = (void *) (varg)); } while (0)
910#define CVOID_TO_LISP(larg,varg) \
911 do { ((larg).cv = (const void *) (varg)); } while (0)
912
913/* Use this for turning a Lisp_Object into a (void *), as when the
914 Lisp_Object is passed into a toolkit callback function. */
915#define LISP_TO_VOID(larg) ((larg).v)
916#define LISP_TO_CVOID(larg) ((larg).cv)
917#endif /* not NO_UNION_TYPE */
918#endif /* USE_X_TOOLKIT */
919
703f2808
JB
920\f
921/* The glyph datatype, used to represent characters on the display. */
922
6b768554
KH
923/* The low 19 bits (CHARACTERBITS) are the character code, and the
924 bits above them except for the topmost two bits are the numeric
925 face ID. If FID is the face ID of a glyph on a frame F, then
926 F->display.x->faces[FID] contains the description of that face.
927 This is an int instead of a short, so we can support a good bunch
928 of face ID's (i.e. 2^(32 - 19 - 2) = 2048 ID's) ; given that we
929 have no mechanism for tossing unused frame face ID's yet, we'll
930 probably run out of 255 pretty quickly. */
703f2808
JB
931#define GLYPH unsigned int
932
6b768554
KH
933/* Mask bit for a glyph of a character which should be written from
934 right to left. */
935#define GLYPH_MASK_REV_DIR 0x80000000
936/* Mask bit for a padding glyph of a multi-column character. */
937#define GLYPH_MASK_PADDING 0x40000000
938/* Mask bits for face. */
939#define GLYPH_MASK_FACE 0x3FF80000
940/* Mask bits for character code. */
941#define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */
942
87485d6f 943#ifdef HAVE_FACES
49b0dd75
KH
944/* The FAST macros assume that we already know we're in an X window. */
945
703f2808 946/* Given a character code and a face ID, return the appropriate glyph. */
000f4621 947#define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
703f2808
JB
948
949/* Return a glyph's character code. */
6b768554 950#define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
703f2808
JB
951
952/* Return a glyph's face ID. */
6b768554 953#define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
49b0dd75
KH
954
955/* Slower versions that test the frame type first. */
956#define MAKE_GLYPH(f, char, face) (FRAME_TERMCAP_P (f) ? (char) \
957 : FAST_MAKE_GLYPH (char, face))
958#define GLYPH_CHAR(f, g) (FRAME_TERMCAP_P (f) ? (g) : FAST_GLYPH_CHAR (g))
959#define GLYPH_FACE(f, g) (FRAME_TERMCAP_P (f) ? (0) : FAST_GLYPH_FACE (g))
87485d6f 960#else /* not HAVE_FACES */
49b0dd75 961#define MAKE_GLYPH(f, char, face) (char)
6b768554
KH
962#define FAST_MAKE_GLYPH(char, face) (char)
963#define GLYPH_CHAR(f, g) ((g) & GLYPH_MASK_CHAR)
964#define FAST_GLYPH_CHAR(g) ((g) & GLYPH_MASK_CHAR)
965#define GLYPH_FACE(f, g) ((g) & GLYPH_MASK_FACE)
966#define FAST_GLYPH_FACE(g) ((g) & GLYPH_MASK_FACE)
87485d6f 967#endif /* not HAVE_FACES */
703f2808 968
b96656ce
KH
969/* Return 1 iff GLYPH contains valid character code. */
970#define GLYPH_CHAR_VALID_P(glyph) \
971 ((GLYPH) (FAST_GLYPH_CHAR (glyph)) <= MAX_CHAR)
972
4606cc9d
RS
973/* The ID of the mode line highlighting face. */
974#define GLYPH_MODE_LINE_FACE 1
3cfe6dfd
JB
975\f
976/* Data type checking */
977
efb859b4 978#define NILP(x) (XFASTINT (x) == XFASTINT (Qnil))
f498e3b2 979#define GC_NILP(x) GC_EQ (x, Qnil)
3cfe6dfd 980
4746118a 981#ifdef LISP_FLOAT_TYPE
c5af3bb9 982#define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
c1a2bfad 983#define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
4746118a 984#else
c5af3bb9 985#define NUMBERP(x) (INTEGERP (x))
c1a2bfad 986#define GC_NUMBERP(x) (GC_INTEGERP (x))
4746118a 987#endif
a4a9f09f 988#define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
c1a2bfad 989#define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
4746118a 990
edfa9106 991#define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
c1a2bfad 992#define GC_INTEGERP(x) (XGCTYPE ((x)) == Lisp_Int)
edfa9106 993#define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
c1a2bfad 994#define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
84d1833e 995#define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
c1a2bfad 996#define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
b5088f80
KH
997#define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
998#define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
edfa9106 999#define STRINGP(x) (XTYPE ((x)) == Lisp_String)
c1a2bfad 1000#define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
3cfe6dfd 1001#define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
c1a2bfad 1002#define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
7c06ac2b 1003
20280af7 1004#ifdef LISP_FLOAT_TYPE
edfa9106 1005#define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
c1a2bfad 1006#define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
20280af7
JB
1007#else
1008#define FLOATP(x) (0)
c1a2bfad 1009#define GC_FLOATP(x) (0)
20280af7 1010#endif
b5088f80
KH
1011#define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1012#define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
a7aa28f6
RS
1013#define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1014#define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1015#define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1016#define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1017#define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1018#define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1019#define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1020#define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1021#define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1022#define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1023#define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1024#define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1025#define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1026#define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1027#define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1028#define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1029#define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1030#define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
edfa9106 1031
7c06ac2b 1032
303a5c93 1033/* True if object X is a pseudovector whose code is CODE. */
7c06ac2b
RS
1034#define PSEUDOVECTORP(x, code) \
1035 (VECTORLIKEP (x) \
1036 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1037 == (PSEUDOVECTOR_FLAG | (code))))
1038
303a5c93 1039/* True if object X is a pseudovector whose code is CODE.
7c06ac2b
RS
1040 This one works during GC. */
1041#define GC_PSEUDOVECTORP(x, code) \
1042 (GC_VECTORLIKEP (x) \
1043 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1044 == (PSEUDOVECTOR_FLAG | (code))))
1045
1046/* Test for specific pseudovector types. */
1047#define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1048#define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1049#define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
1050#define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
1051#define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
1052#define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
1053#define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
1054#define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
1055#define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
1056#define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
99a3d506
RS
1057#define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
1058#define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
608ff985
RS
1059#define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1060#define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1061#define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1062#define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
7c06ac2b
RS
1063#define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
1064#define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
ea724a01
KH
1065
1066#define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
7c06ac2b 1067\f
3cfe6dfd 1068#define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
f498e3b2 1069#define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
4746118a 1070
3cfe6dfd 1071#define CHECK_LIST(x, i) \
c5af3bb9 1072 do { if (!CONSP ((x)) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
3cfe6dfd
JB
1073
1074#define CHECK_STRING(x, i) \
c5af3bb9 1075 do { if (!STRINGP ((x))) x = wrong_type_argument (Qstringp, (x)); } while (0)
3cfe6dfd
JB
1076
1077#define CHECK_CONS(x, i) \
c5af3bb9 1078 do { if (!CONSP ((x))) x = wrong_type_argument (Qconsp, (x)); } while (0)
3cfe6dfd
JB
1079
1080#define CHECK_SYMBOL(x, i) \
c5af3bb9 1081 do { if (!SYMBOLP ((x))) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
3cfe6dfd 1082
608ff985 1083#define CHECK_CHAR_TABLE(x, i) \
a97eb3f3 1084 do { if (!CHAR_TABLE_P ((x))) \
608ff985
RS
1085 x = wrong_type_argument (Qchar_table_p, (x)); } while (0)
1086
3cfe6dfd 1087#define CHECK_VECTOR(x, i) \
c5af3bb9 1088 do { if (!VECTORP ((x))) x = wrong_type_argument (Qvectorp, (x)); } while (0)
3cfe6dfd 1089
7f73dc9d
RS
1090#define CHECK_VECTOR_OR_CHAR_TABLE(x, i) \
1091 do { if (!VECTORP ((x)) && !CHAR_TABLE_P ((x))) \
1092 x = wrong_type_argument (Qvector_or_char_table_p, (x)); \
1093 } while (0)
1094
3cfe6dfd 1095#define CHECK_BUFFER(x, i) \
c5af3bb9 1096 do { if (!BUFFERP ((x))) x = wrong_type_argument (Qbufferp, (x)); } while (0)
3cfe6dfd
JB
1097
1098#define CHECK_WINDOW(x, i) \
c5af3bb9 1099 do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
3cfe6dfd 1100
03273ec5 1101/* This macro rejects windows on the interior of the window tree as
e98227af 1102 "dead", which is what we want; this is an argument-checking macro, and
03273ec5
JB
1103 the user should never get access to interior windows.
1104
1105 A window of any sort, leaf or interior, is dead iff the buffer,
1106 vchild, and hchild members are all nil. */
1107
1108#define CHECK_LIVE_WINDOW(x, i) \
2ad18bfd 1109 do { \
c5af3bb9 1110 if (!WINDOWP ((x)) \
03273ec5 1111 || NILP (XWINDOW ((x))->buffer)) \
806b4d9b 1112 x = wrong_type_argument (Qwindow_live_p, (x)); \
2ad18bfd 1113 } while (0)
03273ec5 1114
3cfe6dfd 1115#define CHECK_PROCESS(x, i) \
c5af3bb9 1116 do { if (!PROCESSP ((x))) x = wrong_type_argument (Qprocessp, (x)); } while (0)
3cfe6dfd
JB
1117
1118#define CHECK_NUMBER(x, i) \
c5af3bb9 1119 do { if (!INTEGERP ((x))) x = wrong_type_argument (Qintegerp, (x)); } while (0)
3cfe6dfd
JB
1120
1121#define CHECK_NATNUM(x, i) \
a4a9f09f 1122 do { if (!NATNUMP (x)) x = wrong_type_argument (Qwholenump, (x)); } while (0)
3cfe6dfd
JB
1123
1124#define CHECK_MARKER(x, i) \
c5af3bb9 1125 do { if (!MARKERP ((x))) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
3cfe6dfd
JB
1126
1127#define CHECK_NUMBER_COERCE_MARKER(x, i) \
221f4ef3 1128 do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
c5af3bb9 1129 else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
3cfe6dfd
JB
1130
1131#ifdef LISP_FLOAT_TYPE
1132
3cfe6dfd
JB
1133#define XFLOATINT(n) extract_float((n))
1134
1135#define CHECK_FLOAT(x, i) \
c5af3bb9 1136 do { if (!FLOATP (x)) \
2ad18bfd 1137 x = wrong_type_argument (Qfloatp, (x)); } while (0)
3cfe6dfd
JB
1138
1139#define CHECK_NUMBER_OR_FLOAT(x, i) \
c5af3bb9 1140 do { if (!FLOATP (x) && !INTEGERP (x)) \
2ad18bfd 1141 x = wrong_type_argument (Qnumberp, (x)); } while (0)
3cfe6dfd
JB
1142
1143#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
221f4ef3 1144 do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
c5af3bb9 1145 else if (!INTEGERP (x) && !FLOATP (x)) \
2ad18bfd 1146 x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
3cfe6dfd
JB
1147
1148#else /* Not LISP_FLOAT_TYPE */
1149
1150#define CHECK_NUMBER_OR_FLOAT CHECK_NUMBER
1151
1152#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER CHECK_NUMBER_COERCE_MARKER
1153
1154#define XFLOATINT(n) XINT((n))
1155#endif /* LISP_FLOAT_TYPE */
1156
20280af7 1157#define CHECK_OVERLAY(x, i) \
c5af3bb9 1158 do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
20280af7 1159
3cfe6dfd
JB
1160/* Cast pointers to this type to compare them. Some machines want int. */
1161#ifndef PNTR_COMPARISON_TYPE
1162#define PNTR_COMPARISON_TYPE unsigned int
1163#endif
1164\f
1165/* Define a built-in function for calling from Lisp.
1166 `lname' should be the name to give the function in Lisp,
1167 as a null-terminated C string.
1168 `fnname' should be the name of the function in C.
1169 By convention, it starts with F.
1170 `sname' should be the name for the C constant structure
1171 that records information on this function for internal use.
1172 By convention, it should be the same as `fnname' but with S instead of F.
1173 It's too bad that C macros can't compute this from `fnname'.
1174 `minargs' should be a number, the minimum number of arguments allowed.
1175 `maxargs' should be a number, the maximum number of arguments allowed,
1176 or else MANY or UNEVALLED.
1177 MANY means pass a vector of evaluated arguments,
1178 in the form of an integer number-of-arguments
1179 followed by the address of a vector of Lisp_Objects
1180 which contains the argument values.
1181 UNEVALLED means pass the list of unevaluated arguments
1182 `prompt' says how to read arguments for an interactive call.
eab9d423 1183 See the doc string for `interactive'.
3cfe6dfd 1184 A null string means call interactively with no arguments.
eab9d423 1185 `doc' is documentation for the user. */
3cfe6dfd 1186
5125ca93 1187#if !defined (__STDC__) || defined (USE_NONANSI_DEFUN)
7c06ac2b
RS
1188#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1189 Lisp_Object fnname (); \
1190 struct Lisp_Subr sname = \
1191 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1192 fnname, minargs, maxargs, lname, prompt, 0}; \
3cfe6dfd
JB
1193 Lisp_Object fnname
1194
c451d7b1
RS
1195#else
1196
1197/* This version of DEFUN declares a function prototype with the right
99a3d506 1198 arguments, so we can catch errors with maxargs at compile-time. */
7c06ac2b
RS
1199#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1200 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
1201 struct Lisp_Subr sname = \
1202 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1203 fnname, minargs, maxargs, lname, prompt, 0}; \
c451d7b1
RS
1204 Lisp_Object fnname
1205
1206/* Note that the weird token-substitution semantics of ANSI C makes
99a3d506 1207 this work for MANY and UNEVALLED. */
c451d7b1
RS
1208#define DEFUN_ARGS_MANY (int, Lisp_Object *)
1209#define DEFUN_ARGS_UNEVALLED (Lisp_Object)
1210#define DEFUN_ARGS_0 (void)
1211#define DEFUN_ARGS_1 (Lisp_Object)
1212#define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
1213#define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
1214#define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1215#define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1216 Lisp_Object)
1217#define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1218 Lisp_Object, Lisp_Object)
1219#define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1220 Lisp_Object, Lisp_Object, Lisp_Object)
5593f7e3
KH
1221#define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1222 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
c451d7b1
RS
1223#endif
1224
526a2be7
AS
1225/* Declare the prototype for a general external function. */
1226#ifdef __STDC__
1227#define P_(proto) proto
1228#else
1229#define P_(proto) ()
1230#endif
1231
3cfe6dfd 1232/* defsubr (Sname);
99a3d506 1233 is how we define the symbol for function `name' at start-up time. */
526a2be7 1234extern void defsubr P_ ((struct Lisp_Subr *));
3cfe6dfd
JB
1235
1236#define MANY -2
1237#define UNEVALLED -1
1238
526a2be7
AS
1239extern void defvar_lisp P_ ((char *, Lisp_Object *));
1240extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
1241extern void defvar_bool P_ ((char *, int *));
1242extern void defvar_int P_ ((char *, int *));
1243extern void defvar_per_buffer P_ ((char *, Lisp_Object *, Lisp_Object, char *));
1244extern void defvar_kboard P_ ((char *, int));
3cfe6dfd
JB
1245
1246/* Macros we use to define forwarded Lisp variables.
1247 These are used in the syms_of_FILENAME functions. */
1248
3cfe6dfd
JB
1249#define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1250#define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1251#define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1252#define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
ef15f270
JB
1253#define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
1254 defvar_per_buffer (lname, vname, type, 0)
32462604
KH
1255#define DEFVAR_KBOARD(lname, vname, doc) \
1256 defvar_kboard (lname, \
1257 (int)((char *)(&current_kboard->vname) \
1258 - (char *)current_kboard))
3cfe6dfd 1259\f
78ca380c
JB
1260/* Structure for recording Lisp call stack for backtrace purposes. */
1261
1262/* The special binding stack holds the outer values of variables while
1263 they are bound by a function application or a let form, stores the
1264 code to be executed for Lisp unwind-protect forms, and stores the C
1265 functions to be called for record_unwind_protect.
1266
1267 If func is non-zero, undoing this binding applies func to old_value;
1268 This implements record_unwind_protect.
1269 If func is zero and symbol is nil, undoing this binding evaluates
1270 the list of forms in old_value; this implements Lisp's unwind-protect
1271 form.
1272 Otherwise, undoing this binding stores old_value as symbol's value; this
1273 undoes the bindings made by a let form or function call. */
3cfe6dfd
JB
1274struct specbinding
1275 {
1276 Lisp_Object symbol, old_value;
526a2be7 1277 Lisp_Object (*func) P_ ((Lisp_Object));
3cfe6dfd
JB
1278 Lisp_Object unused; /* Dividing by 16 is faster than by 12 */
1279 };
1280
1281extern struct specbinding *specpdl;
1282extern struct specbinding *specpdl_ptr;
1283extern int specpdl_size;
1284
78ca380c 1285/* Everything needed to describe an active condition case. */
3cfe6dfd
JB
1286struct handler
1287 {
78ca380c 1288 /* The handler clauses and variable from the condition-case form. */
3cfe6dfd
JB
1289 Lisp_Object handler;
1290 Lisp_Object var;
22bbbd42
RS
1291 /* Fsignal stores here the condition-case clause that applies,
1292 and Fcondition_case thus knows which clause to run. */
1293 Lisp_Object chosen_clause;
78ca380c
JB
1294
1295 /* Used to effect the longjump out to the handler. */
3cfe6dfd 1296 struct catchtag *tag;
78ca380c
JB
1297
1298 /* The next enclosing handler. */
3cfe6dfd
JB
1299 struct handler *next;
1300 };
1301
1302extern struct handler *handlerlist;
1303
1304extern struct catchtag *catchlist;
1305extern struct backtrace *backtrace_list;
1306
22bbbd42
RS
1307extern Lisp_Object memory_signal_data;
1308
3cfe6dfd
JB
1309/* An address near the bottom of the stack.
1310 Tells GC how to save a copy of the stack. */
1311extern char *stack_bottom;
1312
99a3d506 1313/* Check quit-flag and quit if it is non-nil. */
3cfe6dfd
JB
1314
1315#define QUIT \
efb859b4 1316 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
3cfe6dfd
JB
1317 { Vquit_flag = Qnil; Fsignal (Qquit, Qnil); }
1318
1319/* Nonzero if ought to quit now. */
1320
efb859b4 1321#define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
3cfe6dfd 1322\f
8ac90470 1323/* Variables used locally in the following case handling macros. */
2e34157c
RS
1324extern int case_temp1;
1325extern Lisp_Object case_temp2;
8ac90470 1326
e98227af 1327/* Current buffer's map from characters to lower-case characters. */
3cfe6dfd 1328
8ac90470 1329#define DOWNCASE_TABLE current_buffer->downcase_table
3cfe6dfd 1330
e98227af 1331/* Current buffer's map from characters to upper-case characters. */
3cfe6dfd 1332
8ac90470 1333#define UPCASE_TABLE current_buffer->upcase_table
3cfe6dfd 1334
e98227af 1335/* Downcase a character, or make no change if that cannot be done. */
3cfe6dfd 1336
8ac90470
KH
1337#define DOWNCASE(CH) \
1338 ((case_temp1 = (CH), \
1339 case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1), \
1340 NATNUMP (case_temp2)) \
1341 ? XFASTINT (case_temp2) : case_temp1)
3cfe6dfd 1342
e98227af 1343/* 1 if CH is upper case. */
3cfe6dfd 1344
476d47ce 1345#define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
3cfe6dfd 1346
e98227af 1347/* 1 if CH is neither upper nor lower case. */
3cfe6dfd 1348
8ac90470 1349#define NOCASEP(CH) (UPCASE1 (CH) == (CH))
3cfe6dfd 1350
e98227af 1351/* 1 if CH is lower case. */
3cfe6dfd 1352
e98227af 1353#define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
3cfe6dfd 1354
e98227af 1355/* Upcase a character, or make no change if that cannot be done. */
3cfe6dfd 1356
e98227af
KH
1357#define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
1358
1359/* Upcase a character known to be not upper case. */
1360
8ac90470
KH
1361#define UPCASE1(CH) \
1362 ((case_temp1 = (CH), \
1363 case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1), \
1364 NATNUMP (case_temp2)) \
1365 ? XFASTINT (case_temp2) : case_temp1)
3cfe6dfd 1366
c6a3c83c 1367extern Lisp_Object Vascii_downcase_table;
3cfe6dfd 1368\f
99a3d506 1369/* Number of bytes of structure consed since last GC. */
3cfe6dfd
JB
1370
1371extern int consing_since_gc;
1372
99a3d506 1373/* Threshold for doing another gc. */
3cfe6dfd 1374
65deefca 1375extern int gc_cons_threshold;
3cfe6dfd 1376
99a3d506 1377/* Structure for recording stack slots that need marking. */
3cfe6dfd
JB
1378
1379/* This is a chain of structures, each of which points at a Lisp_Object variable
1380 whose value should be marked in garbage collection.
1381 Normally every link of the chain is an automatic variable of a function,
1382 and its `val' points to some argument or local variable of the function.
1383 On exit to the function, the chain is set back to the value it had on entry.
e5f55f07
BF
1384 This way, no link remains in the chain when the stack frame containing the
1385 link disappears.
3cfe6dfd
JB
1386
1387 Every function that can call Feval must protect in this fashion all
99a3d506 1388 Lisp_Object variables whose contents will be used again. */
3cfe6dfd
JB
1389
1390extern struct gcpro *gcprolist;
1391
1392struct gcpro
1393 {
1394 struct gcpro *next;
1395 Lisp_Object *var; /* Address of first protected variable */
1396 int nvars; /* Number of consecutive protected variables */
1397 };
1398
1399#define GCPRO1(varname) \
1400 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1401 gcprolist = &gcpro1; }
1402
1403#define GCPRO2(varname1, varname2) \
1404 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1405 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1406 gcprolist = &gcpro2; }
1407
1408#define GCPRO3(varname1, varname2, varname3) \
1409 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1410 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1411 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1412 gcprolist = &gcpro3; }
1413
1414#define GCPRO4(varname1, varname2, varname3, varname4) \
1415 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1416 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1417 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1418 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1419 gcprolist = &gcpro4; }
1420
c47b8d02
RS
1421#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1422 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1423 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1424 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1425 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1426 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1427 gcprolist = &gcpro5; }
1428
99a3d506 1429/* Call staticpro (&var) to protect static variable `var'. */
3cfe6dfd 1430
526a2be7 1431void staticpro P_ ((Lisp_Object *));
e98227af 1432
3cfe6dfd
JB
1433#define UNGCPRO (gcprolist = gcpro1.next)
1434
5db82c9d 1435/* Evaluate expr, UNGCPRO, and then return the value of expr. */
c47b8d02 1436#define RETURN_UNGCPRO(expr) \
f3ca341e 1437if (1) \
c47b8d02
RS
1438 { \
1439 Lisp_Object ret_ungc_val; \
1440 ret_ungc_val = (expr); \
1441 UNGCPRO; \
1442 return ret_ungc_val; \
1443 } \
f3ca341e 1444else
3cfe6dfd 1445\f
2f69f2ec
RS
1446/* Declare a Lisp-callable function. The MAXARGS parameter has the same
1447 meaning as in the DEFUN macro, and is used to construct a prototype. */
1448#if !defined (__STDC__) || defined (USE_NONANSI_DEFUN)
1449#define EXFUN(fnname, maxargs) \
1450 extern Lisp_Object fnname ()
1451#else
1452/* We can use the same trick as in the DEFUN macro to generate the
1453 appropriate prototype. */
1454#define EXFUN(fnname, maxargs) \
1455 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
1456#endif
1457
526a2be7
AS
1458/* Forward declarations for prototypes. */
1459struct window;
1460struct frame;
2f69f2ec 1461
3cfe6dfd
JB
1462/* Defined in data.c */
1463extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1464extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1465extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1466extern Lisp_Object Qvoid_variable, Qvoid_function;
1467extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1468extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1469extern Lisp_Object Qend_of_file, Qarith_error;
1470extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
83125cd7 1471extern Lisp_Object Qmark_inactive;
3cfe6dfd 1472
59b4254d
JB
1473extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1474extern Lisp_Object Qoverflow_error, Qunderflow_error;
623ed1b0 1475
07a97bf8
RS
1476extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
1477extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
3cfe6dfd
JB
1478extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1479extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
4de86b16 1480extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
7f73dc9d 1481extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
4de86b16 1482extern Lisp_Object Qboundp, Qfboundp;
cde20f41 1483extern Lisp_Object Qbuffer_or_string_p;
3cfe6dfd
JB
1484extern Lisp_Object Qcdr;
1485
1486#ifdef LISP_FLOAT_TYPE
1487extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1488#endif /* LISP_FLOAT_TYPE */
1489
ff11dfa1 1490extern Lisp_Object Qframep;
3cfe6dfd 1491
2f69f2ec
RS
1492EXFUN (Feq, 2);
1493EXFUN (Fnull, 1);
1494EXFUN (Flistp, 1);
1495EXFUN (Fconsp, 1);
1496EXFUN (Fatom, 1);
1497EXFUN (Fnlistp, 1);
1498EXFUN (Fintegerp, 1);
1499EXFUN (Fnatnump, 1);
1500EXFUN (Fsymbolp, 1);
1501EXFUN (Fvectorp, 1);
1502EXFUN (Fstringp, 1);
1503EXFUN (Farrayp, 1);
1504EXFUN (Fsequencep, 1);
1505EXFUN (Fbufferp, 1);
1506EXFUN (Fmarkerp, 1);
1507EXFUN (Fsubrp, 1);
1508EXFUN (Fchar_or_string_p, 1);
1509EXFUN (Finteger_or_marker_p, 1);
3cfe6dfd 1510#ifdef LISP_FLOAT_TYPE
2f69f2ec
RS
1511EXFUN (Ffloatp, 1);
1512EXFUN (Finteger_or_floatp, 1);
1513EXFUN (Finteger_or_float_or_marker_p, 1);
3cfe6dfd
JB
1514#endif /* LISP_FLOAT_TYPE */
1515
2f69f2ec
RS
1516EXFUN (Fcar, 1);
1517EXFUN (Fcar_safe, 1);
1518EXFUN (Fcdr, 1);
1519EXFUN (Fcdr_safe, 1);
1520EXFUN (Fsetcar, 2);
1521EXFUN (Fsetcdr, 2);
1522EXFUN (Fboundp, 1);
1523EXFUN (Ffboundp, 1);
1524EXFUN (Fmakunbound, 1);
1525EXFUN (Ffmakunbound, 1);
1526EXFUN (Fsymbol_function, 1);
1527EXFUN (Fsymbol_plist, 1);
1528EXFUN (Fsymbol_name, 1);
1529extern Lisp_Object indirect_function P_ ((Lisp_Object));
1530EXFUN (Findirect_function, 1);
1531EXFUN (Ffset, 2);
1532EXFUN (Fsetplist, 2);
1533EXFUN (Fsymbol_value, 1);
a154f406 1534extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
2f69f2ec
RS
1535EXFUN (Fset, 2);
1536EXFUN (Fdefault_value, 1);
1537EXFUN (Fset_default, 2);
1538EXFUN (Fdefault_boundp, 1);
1539EXFUN (Fmake_local_variable, 1);
a154f406 1540EXFUN (Flocal_variable_p, 2);
2f69f2ec
RS
1541EXFUN (Flocal_variable_if_set_p, 2);
1542
1543EXFUN (Faref, 2);
1544EXFUN (Faset, 3);
1545
1546EXFUN (Fstring_to_number, 2);
1547EXFUN (Fnumber_to_string, 1);
1548EXFUN (Feqlsign, 2);
1549EXFUN (Fgtr, 2);
1550EXFUN (Flss, 2);
1551EXFUN (Fgeq, 2);
1552EXFUN (Fleq, 2);
1553EXFUN (Fneq, 2);
1554EXFUN (Fzerop, 1);
1555EXFUN (Fplus, MANY);
1556EXFUN (Fminus, MANY);
1557EXFUN (Ftimes, MANY);
1558EXFUN (Fquo, MANY);
1559EXFUN (Frem, 2);
1560EXFUN (Fmax, MANY);
1561EXFUN (Fmin, MANY);
1562EXFUN (Flogand, MANY);
1563EXFUN (Flogior, MANY);
1564EXFUN (Flogxor, MANY);
1565EXFUN (Flognot, 1);
1566EXFUN (Flsh, 2);
1567EXFUN (Fash, 2);
1568
1569EXFUN (Fadd1, 1);
1570EXFUN (Fsub1, 1);
1571
1572extern Lisp_Object long_to_cons P_ ((unsigned long));
1573extern unsigned long cons_to_long P_ ((Lisp_Object));
1574extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object));
1575extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1576extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object));
1577extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1578extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
526a2be7 1579extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, int));
3cfe6dfd 1580
a37e10f9 1581/* Defined in cmds.c */
2f69f2ec
RS
1582EXFUN (Fend_of_line, 1);
1583EXFUN (Fforward_char, 1);
1584EXFUN (Fforward_line, 1);
526a2be7
AS
1585extern int forward_point P_ ((int));
1586extern int internal_self_insert P_ ((int, int));
a37e10f9 1587
6b768554 1588/* Defined in coding.c */
2f69f2ec
RS
1589EXFUN (Fcoding_system_p, 1);
1590EXFUN (Fcheck_coding_system, 1);
34ba1f2e 1591EXFUN (Fread_coding_system, 2);
2f69f2ec 1592EXFUN (Fread_non_nil_coding_system, 1);
a154f406 1593EXFUN (Ffind_operation_coding_system, MANY);
526a2be7
AS
1594EXFUN (Fencode_coding_string, 3);
1595EXFUN (Fdecode_coding_string, 3);
6b768554 1596
5e741a41
RS
1597/* Defined in charset.c */
1598EXFUN (Fchar_bytes, 1);
1599
a37e10f9 1600/* Defined in syntax.c */
2f69f2ec
RS
1601EXFUN (Fforward_word, 1);
1602EXFUN (Fskip_chars_forward, 2);
1603EXFUN (Fskip_chars_backward, 2);
526a2be7
AS
1604EXFUN (Fsyntax_table_p, 1);
1605EXFUN (Fsyntax_table, 0);
1606EXFUN (Fset_syntax_table, 1);
a37e10f9 1607
3cfe6dfd
JB
1608/* Defined in fns.c */
1609extern Lisp_Object Qstring_lessp;
1610extern Lisp_Object Vfeatures;
2f69f2ec
RS
1611EXFUN (Fidentity, 1);
1612EXFUN (Frandom, 1);
1613EXFUN (Flength, 1);
1614EXFUN (Fsafe_length, 1);
1615EXFUN (Fappend, MANY);
1616EXFUN (Fconcat, MANY);
1617EXFUN (Fvconcat, MANY);
1618EXFUN (Fcopy_sequence, 1);
1619EXFUN (Fsubstring, 3);
1620EXFUN (Fnth, 2);
1621EXFUN (Fnthcdr, 2);
1622EXFUN (Fmemq, 2);
1623EXFUN (Fassq, 2);
1624EXFUN (Fassoc, 2);
1625EXFUN (Felt, 2);
1626EXFUN (Fmember, 2);
1627EXFUN (Frassq, 2);
1628EXFUN (Fdelq, 2);
1629EXFUN (Fsort, 2);
1630EXFUN (Freverse, 1);
1631EXFUN (Fnreverse, 1);
1632EXFUN (Fget, 2);
1633EXFUN (Fput, 3);
1634EXFUN (Fequal, 2);
1635EXFUN (Ffillarray, 2);
1636EXFUN (Fnconc, MANY);
1637EXFUN (Fmapcar, 2);
1638EXFUN (Fmapconcat, 3);
1639EXFUN (Fy_or_n_p, 1);
1640extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
1641EXFUN (Ffeaturep, 1);
1642EXFUN (Frequire, 2);
1643EXFUN (Fprovide, 1);
1644extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
1645extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1646extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
1647extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
1648EXFUN (Fcopy_alist, 1);
1649EXFUN (Fplist_get, 2);
1650EXFUN (Fset_char_table_parent, 2);
1651EXFUN (Fchar_table_extra_slot, 2);
526a2be7 1652EXFUN (Fset_char_table_extra_slot, 3);
2f69f2ec
RS
1653EXFUN (Frassoc, 2);
1654EXFUN (Fstring_equal, 2);
1655EXFUN (Fstring_lessp, 2);
526a2be7
AS
1656extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
1657 Lisp_Object, Lisp_Object, Lisp_Object, int,
1658 Lisp_Object *));
2f69f2ec
RS
1659
1660/* Defined in floatfns.c */
1661#ifdef LISP_FLOAT_TYPE
1662extern double extract_float P_ ((Lisp_Object));
1663EXFUN (Ffloat, 1);
1664#endif /* LISP_FLOAT_TYPE */
1665EXFUN (Ftruncate, 2);
3cfe6dfd 1666
c98adc1b 1667/* Defined in insdel.c */
2f69f2ec
RS
1668extern void move_gap P_ ((int));
1669extern void make_gap P_ ((int));
1670extern void insert P_ ((unsigned char *, int));
1671extern void insert_and_inherit P_ ((unsigned char *, int));
1672extern void insert_1 P_ ((unsigned char *, int, int, int));
1673extern void insert_from_string P_ ((Lisp_Object, int, int, int));
1674extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
1675extern void insert_char P_ ((int));
1676extern void insert_string P_ ((char *));
1677extern void insert_before_markers P_ ((unsigned char *, int));
1678extern void insert_before_markers_and_inherit P_ ((unsigned char *, int));
1679extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int));
1680extern void del_range P_ ((int, int));
1681extern void del_range_1 P_ ((int, int, int));
1682extern void modify_region P_ ((struct buffer *, int, int));
1683extern void prepare_to_modify_buffer P_ ((int, int, int *));
1684extern void signal_before_change P_ ((int, int, int *));
1685extern void signal_after_change P_ ((int, int, int));
526a2be7 1686extern void replace_range P_ ((int, int, Lisp_Object, int, int));
c98adc1b 1687
1747fb16 1688/* Defined in dispnew.c */
2f69f2ec
RS
1689EXFUN (Fding, 1);
1690EXFUN (Fredraw_display, 0);
1691EXFUN (Fsleep_for, 2);
1692EXFUN (Fsit_for, 3);
526a2be7
AS
1693extern Lisp_Object sit_for P_ ((int, int, int, int, int));
1694extern void quit_error_check P_ ((void));
1747fb16 1695
c98adc1b 1696/* Defined in xdisp.c */
439ae27b 1697extern Lisp_Object Vmessage_log_max;
2f69f2ec
RS
1698extern void message P_ ((/* char *, ... */));
1699extern void message_nolog P_ ((/* char *, ... */));
1700extern void message1 P_ ((char *));
1701extern void message1_nolog P_ ((char *));
1702extern void message2 P_ ((char *, int));
1703extern void message2_nolog P_ ((char *, int));
1704extern void message_dolog P_ ((char *, int, int));
1705extern void message_log_maybe_newline P_ ((void));
526a2be7
AS
1706extern void update_echo_area P_ ((void));
1707extern void truncate_echo_area P_ ((int));
1708extern void redisplay P_ ((void));
1709extern void redisplay_preserve_echo_area P_ ((void));
1710extern void mark_window_display_accurate P_ ((Lisp_Object, int));
1711extern int invisible_p P_ ((Lisp_Object, Lisp_Object));
1712extern void prepare_menu_bars P_ ((void));
c98adc1b 1713
3cfe6dfd 1714/* Defined in alloc.c */
526a2be7
AS
1715extern void malloc_warning P_ ((char *));
1716extern void memory_full P_ ((void));
1717extern void buffer_memory_full P_ ((void));
3cfe6dfd 1718extern Lisp_Object Vpurify_flag;
2f69f2ec
RS
1719EXFUN (Fcons, 2);
1720EXFUN (Flist, MANY);
1721EXFUN (Fmake_list, 2);
1722extern Lisp_Object allocate_misc P_ ((void));
1723EXFUN (Fmake_vector, 2);
1724EXFUN (Fvector, MANY);
1725EXFUN (Fmake_symbol, 1);
1726EXFUN (Fmake_marker, 0);
1727EXFUN (Fmake_string, 2);
1728extern Lisp_Object build_string P_ ((char *));
1729extern Lisp_Object make_string P_ ((char *, int));
1730extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
1731extern Lisp_Object make_uninit_string P_ ((int));
1732EXFUN (Fpurecopy, 1);
1733extern Lisp_Object make_pure_string P_ ((char *, int));
1734extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
1735extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
1736EXFUN (Fgarbage_collect, 0);
1737EXFUN (Fmake_byte_code, MANY);
1738EXFUN (Fmake_bool_vector, 2);
1739EXFUN (Fmake_char_table, 2);
1740extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
7f73dc9d 1741extern Lisp_Object Qchar_table_extra_slots;
2f69f2ec 1742extern struct Lisp_Vector *allocate_vectorlike P_ ((EMACS_INT));
4d57802e 1743extern int gc_in_progress;
2f69f2ec
RS
1744#ifdef LISP_FLOAT_TYPE
1745extern Lisp_Object make_float P_ ((double));
1746#endif /* LISP_FLOAT_TYPE */
526a2be7
AS
1747extern void display_malloc_warning P_ ((void));
1748extern int inhibit_garbage_collection P_ ((void));
1749extern void free_marker P_ ((Lisp_Object));
1750extern void free_cons P_ ((struct Lisp_Cons *));
3cfe6dfd
JB
1751
1752/* Defined in print.c */
1753extern Lisp_Object Vprin1_to_string_buffer;
2f69f2ec
RS
1754EXFUN (Fprin1, 2);
1755EXFUN (Fprin1_to_string, 2);
1756EXFUN (Fprinc, 2);
1757EXFUN (Fterpri, 1);
1758EXFUN (Fprint, 2);
1759EXFUN (Ferror_message_string, 1);
3cfe6dfd 1760extern Lisp_Object Vstandard_output, Qstandard_output;
9453ea7b 1761extern Lisp_Object Qexternal_debugging_output;
2f69f2ec 1762extern void temp_output_buffer_setup P_ ((char *));
3cfe6dfd
JB
1763extern int print_level, print_escape_newlines;
1764extern Lisp_Object Qprint_escape_newlines;
526a2be7
AS
1765extern void write_string P_ ((char *, int));
1766extern void write_string_1 P_ ((char *, int, Lisp_Object));
1767extern void print_error_message P_ ((Lisp_Object, Lisp_Object));
1768extern Lisp_Object internal_with_output_to_temp_buffer
3d03cf9f 1769 P_ ((char *, Lisp_Object (*) (), Lisp_Object));
526a2be7
AS
1770extern void float_to_string P_ ((unsigned char *, double));
1771
1772/* Defined in doprnt.c */
1773extern int doprnt P_ ((char *, int, char *, char *, int, char **));
1774extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
3cfe6dfd
JB
1775
1776/* Defined in lread.c */
1777extern Lisp_Object Qvariable_documentation, Qstandard_input;
1778extern Lisp_Object Vobarray, Vstandard_input;
2f69f2ec
RS
1779EXFUN (Fread, 1);
1780EXFUN (Fread_from_string, 3);
1781EXFUN (Fintern, 2);
1782EXFUN (Fintern_soft, 2);
5d8c7983 1783EXFUN (Fload, 5);
2f69f2ec
RS
1784EXFUN (Fget_file_char, 0);
1785EXFUN (Fread_char, 0);
1786extern Lisp_Object read_filtered_event P_ ((int, int, int));
1787EXFUN (Feval_region, 3);
1788extern Lisp_Object intern P_ ((char *));
1789extern Lisp_Object make_symbol P_ ((char *));
1790extern Lisp_Object oblookup P_ ((Lisp_Object, char *, int));
c5e3de70
RS
1791#define LOADHIST_ATTACH(x) \
1792 if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
1793extern Lisp_Object Vcurrent_load_list;
1794extern Lisp_Object Vload_history;
526a2be7
AS
1795extern int openp P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object *, int));
1796extern int isfloat_string P_ ((char *));
1797extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
1798 Lisp_Object));
1799extern void dir_warning P_ ((char *, Lisp_Object));
1800extern void close_load_descs P_ ((void));
3cfe6dfd
JB
1801
1802/* Defined in eval.c */
1803extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
ad236261 1804extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
3cfe6dfd
JB
1805extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
1806extern Lisp_Object Vautoload_queue;
973e8873 1807extern Lisp_Object Vdebug_on_error;
f1b6e5fc
SM
1808/* To run a normal hook, use the appropriate function from the list below.
1809 The calling convention:
1810
846d69ac 1811 if (!NILP (Vrun_hooks))
f1b6e5fc
SM
1812 call1 (Vrun_hooks, Qmy_funny_hook);
1813
1814 should no longer be used. */
3cfe6dfd 1815extern Lisp_Object Vrun_hooks;
2f69f2ec
RS
1816EXFUN (Frun_hooks, MANY);
1817EXFUN (Frun_hook_with_args, MANY);
1818EXFUN (Frun_hook_with_args_until_success, MANY);
1819EXFUN (Frun_hook_with_args_until_failure, MANY);
526a2be7
AS
1820extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
1821extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2f69f2ec
RS
1822EXFUN (Fand, UNEVALLED);
1823EXFUN (For, UNEVALLED);
1824EXFUN (Fif, UNEVALLED);
1825EXFUN (Fprogn, UNEVALLED);
1826EXFUN (Fprog1, UNEVALLED);
1827EXFUN (Fprog2, UNEVALLED);
1828EXFUN (Fsetq, UNEVALLED);
1829EXFUN (Fquote, UNEVALLED);
1830EXFUN (Fuser_variable_p, 1);
1831EXFUN (Finteractive_p, 0);
1832EXFUN (Fdefun, UNEVALLED);
1833EXFUN (Flet, UNEVALLED);
1834EXFUN (FletX, UNEVALLED);
1835EXFUN (Fwhile, UNEVALLED);
1836EXFUN (Fcatch, UNEVALLED);
1837EXFUN (Fthrow, 2);
1838EXFUN (Funwind_protect, UNEVALLED);
1839EXFUN (Fcondition_case, UNEVALLED);
1840EXFUN (Fsignal, 2);
1841EXFUN (Fautoload, 5);
1842EXFUN (Fcommandp, 1);
1843EXFUN (Feval, 1);
1844EXFUN (Fapply, MANY);
1845EXFUN (Ffuncall, MANY);
1846EXFUN (Fbacktrace, 0);
1847extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
1848extern Lisp_Object call0 P_ ((Lisp_Object));
1849extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
1850extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1851extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
1852extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
1853extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
1854extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
1855EXFUN (Fdo_auto_save, 2);
1856extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
1857extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
1858extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
1859extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
526a2be7
AS
1860extern void specbind P_ ((Lisp_Object, Lisp_Object));
1861extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
2f69f2ec
RS
1862extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
1863extern void error P_ ((/* char *, ... */));
526a2be7 1864extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
2f69f2ec
RS
1865extern Lisp_Object un_autoload P_ ((Lisp_Object));
1866EXFUN (Ffetch_bytecode, 1);
3cfe6dfd
JB
1867
1868/* Defined in editfns.c */
2f69f2ec
RS
1869EXFUN (Fgoto_char, 1);
1870EXFUN (Fpoint_min_marker, 0);
1871EXFUN (Fpoint_max_marker, 0);
1872EXFUN (Fpoint_min, 0);
1873EXFUN (Fpoint_max, 0);
1874EXFUN (Fpoint, 0);
1875EXFUN (Fpoint_marker, 0);
1876EXFUN (Fmark_marker, 0);
1877EXFUN (Fline_beginning_position, 1);
1878EXFUN (Fline_end_position, 1);
1879EXFUN (Ffollowing_char, 0);
1880EXFUN (Fprevious_char, 0);
1881EXFUN (Fchar_after, 1);
1882EXFUN (Finsert, MANY);
1883EXFUN (Finsert_and_inherit, MANY);
1884EXFUN (Finsert_before_markers, MANY);
1885EXFUN (Finsert_buffer_substring, 3);
1886EXFUN (Finsert_char, 3);
526a2be7 1887extern void insert1 P_ ((Lisp_Object));
2f69f2ec
RS
1888EXFUN (Feolp, 0);
1889EXFUN (Feobp, 0);
1890EXFUN (Fbolp, 0);
1891EXFUN (Fbobp, 0);
1892EXFUN (Fformat, MANY);
1893extern Lisp_Object format1 P_ ((/* char *, ... */));
1894extern Lisp_Object make_buffer_string P_ ((int, int, int));
1895EXFUN (Fbuffer_substring, 2);
1896EXFUN (Fbuffer_string, 0);
1897extern Lisp_Object save_excursion_save P_ ((void));
1898extern Lisp_Object save_restriction_save P_ ((void));
1899extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
1900extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
1901EXFUN (Fchar_to_string, 1);
1902EXFUN (Fdelete_region, 2);
1903EXFUN (Fnarrow_to_region, 2);
1904EXFUN (Fwiden, 0);
1905EXFUN (Fuser_login_name, 1);
1906EXFUN (Fsystem_name, 0);
526a2be7 1907extern int clip_to_bounds P_ ((int, int, int));
3cfe6dfd
JB
1908
1909/* defined in buffer.c */
526a2be7 1910extern void nsberror P_ ((Lisp_Object));
2f69f2ec
RS
1911EXFUN (Foverlay_start, 1);
1912EXFUN (Foverlay_end, 1);
1913extern void adjust_overlays_for_insert P_ ((int, int));
1914extern void adjust_overlays_for_delete P_ ((int, int));
1915extern void fix_overlays_in_range P_ ((int, int));
526a2be7
AS
1916extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
1917 Lisp_Object, Lisp_Object, Lisp_Object));
2f69f2ec 1918extern int overlay_touches_p P_ ((int));
628300ba 1919extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
2f69f2ec
RS
1920EXFUN (Fget_buffer, 1);
1921EXFUN (Fget_buffer_create, 1);
1922EXFUN (Fset_buffer, 1);
1923EXFUN (Fbarf_if_buffer_read_only, 0);
1924EXFUN (Fcurrent_buffer, 0);
1925EXFUN (Fswitch_to_buffer, 2);
1926EXFUN (Fpop_to_buffer, 3);
1927EXFUN (Fother_buffer, 2);
1928EXFUN (Foverlay_get, 2);
1929EXFUN (Fbuffer_modified_p, 1);
1930EXFUN (Fset_buffer_modified_p, 1);
1931EXFUN (Fkill_buffer, 1);
1932EXFUN (Fkill_all_local_variables, 0);
1933EXFUN (Fbuffer_disable_undo, 1);
1934EXFUN (Fbuffer_enable_undo, 1);
1935EXFUN (Ferase_buffer, 0);
20280af7 1936extern Lisp_Object Qoverlayp;
2f69f2ec 1937extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
3cfe6dfd 1938extern struct buffer *all_buffers;
2f69f2ec 1939EXFUN (Fprevious_overlay_change, 1);
3cfe6dfd
JB
1940
1941/* defined in marker.c */
1942
2f69f2ec
RS
1943EXFUN (Fmarker_position, 1);
1944EXFUN (Fmarker_buffer, 1);
1945EXFUN (Fcopy_marker, 2);
1946EXFUN (Fset_marker, 3);
526a2be7
AS
1947extern int marker_position P_ ((Lisp_Object));
1948extern void unchain_marker P_ ((Lisp_Object));
1949extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
3cfe6dfd
JB
1950
1951/* Defined in fileio.c */
1952
1953extern Lisp_Object Qfile_error;
2f69f2ec
RS
1954EXFUN (Ffind_file_name_handler, 2);
1955EXFUN (Ffile_name_as_directory, 1);
1956EXFUN (Fexpand_file_name, 2);
1957EXFUN (Ffile_name_nondirectory, 1);
1958EXFUN (Fsubstitute_in_file_name, 1);
1959EXFUN (Ffile_symlink_p, 1);
1960EXFUN (Fverify_visited_file_modtime, 1);
1961EXFUN (Ffile_exists_p, 1);
1962EXFUN (Ffile_name_absolute_p, 1);
1963EXFUN (Fdirectory_file_name, 1);
1964EXFUN (Ffile_name_directory, 1);
1965extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
1966EXFUN (Ffile_accessible_directory_p, 1);
1967EXFUN (Funhandled_file_name_directory, 1);
1968EXFUN (Ffile_directory_p, 1);
1969EXFUN (Fwrite_region, 6);
1970EXFUN (Ffile_readable_p, 1);
1971EXFUN (Ffile_executable_p, 1);
1972EXFUN (Fread_file_name, 5);
526a2be7
AS
1973extern void report_file_error P_ ((char *, Lisp_Object));
1974extern int internal_delete_file P_ ((Lisp_Object));
3cfe6dfd
JB
1975
1976/* Defined in abbrev.c */
1977
1978extern Lisp_Object Vfundamental_mode_abbrev_table;
1979
1980/* defined in search.c */
2f69f2ec
RS
1981EXFUN (Fstring_match, 3);
1982extern void restore_match_data P_ ((void));
1983EXFUN (Fmatch_data, 2);
1984EXFUN (Fstore_match_data, 1);
1985EXFUN (Fmatch_beginning, 1);
1986EXFUN (Fmatch_end, 1);
526a2be7
AS
1987extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
1988extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, char *));
1989extern int scan_buffer P_ ((int, int, int, int, int *, int));
1990extern int find_next_newline P_ ((int, int));
1991extern int find_next_newline_no_quit P_ ((int, int));
1992extern int find_before_next_newline P_ ((int, int, int));
3cfe6dfd
JB
1993
1994/* defined in minibuf.c */
1995
1996extern Lisp_Object last_minibuf_string;
526a2be7 1997extern void choose_minibuf_frame P_ ((void));
5593f7e3
KH
1998EXFUN (Fcompleting_read, 8);
1999EXFUN (Fread_from_minibuffer, 7);
2f69f2ec
RS
2000EXFUN (Fread_variable, 2);
2001EXFUN (Fread_buffer, 3);
2002EXFUN (Fread_minibuffer, 2);
2003EXFUN (Feval_minibuffer, 2);
5593f7e3
KH
2004EXFUN (Fread_string, 5);
2005EXFUN (Fread_no_blanks_input, 3);
2f69f2ec 2006extern Lisp_Object get_minibuffer P_ ((int));
526a2be7 2007extern void temp_echo_area_glyphs P_ ((char *));
3cfe6dfd
JB
2008
2009/* Defined in callint.c */
2010
de7885bb 2011extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
3cfe6dfd 2012extern Lisp_Object Vcommand_history;
7fd61057 2013extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
2f69f2ec
RS
2014EXFUN (Fcall_interactively, 3);
2015EXFUN (Fprefix_numeric_value, 1);
3cfe6dfd
JB
2016
2017/* defined in casefiddle.c */
2018
2f69f2ec
RS
2019EXFUN (Fdowncase, 1);
2020EXFUN (Fupcase, 1);
2021EXFUN (Fcapitalize, 1);
2022EXFUN (Fupcase_region, 2);
2023EXFUN (Fupcase_initials, 1);
2024EXFUN (Fupcase_initials_region, 2);
3cfe6dfd 2025
1747fb16
RS
2026/* defined in casetab.c */
2027
2f69f2ec
RS
2028EXFUN (Fset_case_table, 1);
2029EXFUN (Fset_standard_case_table, 1);
1747fb16 2030
3cfe6dfd
JB
2031/* defined in keyboard.c */
2032
2033extern Lisp_Object Qdisabled;
4b657f72 2034extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
2f69f2ec
RS
2035EXFUN (Fdiscard_input, 0);
2036EXFUN (Frecursive_edit, 0);
2037EXFUN (Fcommand_execute, 4);
2038EXFUN (Finput_pending_p, 0);
2039extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
f498e3b2 2040extern Lisp_Object Qvertical_scroll_bar;
084cd810 2041extern void discard_mouse_events ();
2f69f2ec 2042EXFUN (Fevent_convert_list, 1);
2f69f2ec 2043EXFUN (Fread_key_sequence, 4);
526a2be7
AS
2044EXFUN (Fset_input_mode, 4);
2045extern int detect_input_pending P_ ((void));
2046extern int detect_input_pending_run_timers P_ ((int));
2047extern void safe_run_hooks P_ ((Lisp_Object));
2048extern void cmd_error_internal P_ ((Lisp_Object, char *));
2049extern Lisp_Object command_loop_1 P_ ((void));
2050extern Lisp_Object recursive_edit_1 P_ ((void));
2051extern void record_auto_save P_ ((void));
3cfe6dfd
JB
2052
2053/* defined in keymap.c */
2054
c451d7b1 2055extern Lisp_Object Qkeymap, Qmenu_bar;
3cfe6dfd 2056extern Lisp_Object current_global_map;
526a2be7
AS
2057EXFUN (Fmake_sparse_keymap, 1);
2058EXFUN (Fcopy_keymap, 1);
2f69f2ec 2059EXFUN (Fdefine_key, 3);
526a2be7 2060EXFUN (Flookup_key, 3);
2f69f2ec
RS
2061EXFUN (Fkey_binding, 2);
2062EXFUN (Fkey_description, 1);
2063EXFUN (Fsingle_key_description, 1);
2064EXFUN (Fwhere_is_internal, 4);
2065extern Lisp_Object access_keymap P_ ((Lisp_Object, Lisp_Object, int, int));
2066extern Lisp_Object store_in_keymap P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2067extern Lisp_Object get_keyelt P_ ((Lisp_Object, int));
2068extern Lisp_Object get_keymap P_ ((Lisp_Object));
2069extern Lisp_Object get_keymap_1 P_ ((Lisp_Object, int, int));
526a2be7
AS
2070extern void describe_vector P_ ((Lisp_Object, Lisp_Object,
2071 void (*) (Lisp_Object), int,
2072 Lisp_Object, Lisp_Object, int *, int));
2073extern void describe_map_tree P_ ((Lisp_Object, int, Lisp_Object, Lisp_Object,
2074 char *, int, int, int));
2075extern int current_minor_maps P_ ((Lisp_Object **, Lisp_Object **));
2076extern void initial_define_key P_ ((Lisp_Object, int, char *));
2077extern void initial_define_lispy_key P_ ((Lisp_Object, char *, char *));
2078extern void fix_submap_inheritance P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
3cfe6dfd
JB
2079
2080/* defined in indent.c */
2f69f2ec
RS
2081EXFUN (Fvertical_motion, 2);
2082EXFUN (Findent_to, 2);
2083EXFUN (Fcurrent_column, 0);
2084EXFUN (Fmove_to_column, 2);
526a2be7
AS
2085extern int current_column P_ ((void));
2086extern void invalidate_current_column P_ ((void));
2087extern int pos_tab_offset P_ ((struct window *, int));
2088extern int indented_beyond_p P_ ((int, int));
3cfe6dfd
JB
2089
2090/* defined in window.c */
afd0d237 2091extern Lisp_Object Qwindowp, Qwindow_live_p;
2f69f2ec 2092EXFUN (Fselected_window, 0);
526a2be7
AS
2093EXFUN (Fnext_window, 3);
2094EXFUN (Fdelete_window, 1);
2095EXFUN (Fselect_window, 1);
2096EXFUN (Fset_window_buffer, 2);
2f69f2ec
RS
2097EXFUN (Fget_buffer_window, 2);
2098EXFUN (Fsave_window_excursion, UNEVALLED);
526a2be7 2099EXFUN (Fsplit_window, 3);
2f69f2ec
RS
2100EXFUN (Fset_window_configuration, 1);
2101EXFUN (Fcurrent_window_configuration, 1);
2102EXFUN (Fcoordinates_in_window_p, 2);
2103EXFUN (Fwindow_at, 3);
2104EXFUN (Fpos_visible_in_window_p, 2);
526a2be7
AS
2105extern int window_internal_height P_ ((struct window *));
2106extern int window_internal_width P_ ((struct window *));
2f69f2ec
RS
2107EXFUN (Frecenter, 1);
2108EXFUN (Fscroll_other_window, 1);
2109EXFUN (Fset_window_start, 3);
2110extern void temp_output_buffer_show P_ ((Lisp_Object));
526a2be7 2111extern void replace_buffer_in_all_windows P_ ((Lisp_Object));
3cfe6dfd 2112
ff11dfa1 2113/* defined in frame.c */
362fb47a 2114extern Lisp_Object Qvisible;
526a2be7 2115extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
2f69f2ec
RS
2116extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
2117extern Lisp_Object do_switch_frame P_ ((Lisp_Object, Lisp_Object, int));
526a2be7 2118extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
2f69f2ec
RS
2119extern Lisp_Object frame_buffer_predicate P_ ((void));
2120EXFUN (Fframep, 1);
2121EXFUN (Fselect_frame, 2);
2122EXFUN (Fselected_frame, 0);
2123EXFUN (Fwindow_frame, 1);
2124EXFUN (Fframe_root_window, 1);
2125EXFUN (Fframe_first_window, 1);
2126EXFUN (Fframe_selected_window, 1);
2127EXFUN (Fframe_list, 0);
2128EXFUN (Fnext_frame, 2);
2129EXFUN (Fdelete_frame, 2);
2130EXFUN (Fset_mouse_position, 3);
2131EXFUN (Fmake_frame_visible, 1);
2132EXFUN (Fmake_frame_invisible, 2);
2133EXFUN (Ficonify_frame, 1);
2134EXFUN (Fframe_visible_p, 1);
2135EXFUN (Fvisible_frame_list, 0);
2136EXFUN (Fframe_parameters, 1);
2137EXFUN (Fmodify_frame_parameters, 2);
2138EXFUN (Fset_frame_height, 3);
2139EXFUN (Fset_frame_width, 3);
2140EXFUN (Fset_frame_size, 3);
2141EXFUN (Fset_frame_position, 3);
2142EXFUN (Fraise_frame, 1);
2143EXFUN (Fredirect_frame_focus, 2);
526a2be7 2144EXFUN (Fset_frame_selected_window, 2);
2f69f2ec 2145extern Lisp_Object frame_buffer_list P_ ((void));
526a2be7
AS
2146extern void frames_discard_buffer P_ ((Lisp_Object));
2147extern void set_frame_buffer_list P_ ((Lisp_Object));
2148extern void frames_bury_buffer P_ ((Lisp_Object));
3cfe6dfd
JB
2149
2150/* defined in emacs.c */
2f69f2ec 2151extern Lisp_Object decode_env_path P_ ((char *, char *));
3530d534 2152extern Lisp_Object Vinvocation_name, Vinvocation_directory;
e6faba7f 2153extern Lisp_Object Vinstallation_directory;
2f69f2ec
RS
2154EXFUN (Fkill_emacs, 1);
2155void shut_down_emacs P_ ((int, int, Lisp_Object));
3cfe6dfd
JB
2156/* Nonzero means don't do interactive redisplay and don't change tty modes */
2157extern int noninteractive;
2158/* Nonzero means don't do use window-system-specific display code */
2159extern int inhibit_window_system;
99a3d506 2160/* Nonzero means that a filter or a sentinel is running. */
7074fde6 2161extern int running_asynch_code;
3cfe6dfd
JB
2162
2163/* defined in process.c */
2f69f2ec
RS
2164EXFUN (Fget_process, 1);
2165EXFUN (Fget_buffer_process, 1);
2166EXFUN (Fprocessp, 1);
2167EXFUN (Fprocess_status, 1);
2168EXFUN (Fkill_process, 2);
2169EXFUN (Fprocess_send_eof, 1);
2170EXFUN (Fwaiting_for_user_input_p, 0);
6efad63b 2171extern Lisp_Object Qprocessp;
526a2be7
AS
2172extern void kill_buffer_processes P_ ((Lisp_Object));
2173extern int wait_reading_process_input P_ ((int, int, Lisp_Object, int));
2174extern void deactivate_process P_ ((Lisp_Object));
2175extern void add_keyboard_wait_descriptor P_ ((int));
2176extern void delete_keyboard_wait_descriptor P_ ((int));
2177extern void close_process_descs P_ ((void));
2178extern void status_notify P_ ((void));
2179extern int read_process_output P_ ((Lisp_Object, int));
3cfe6dfd
JB
2180
2181/* defined in callproc.c */
9453ea7b 2182extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
c65be0e1 2183extern Lisp_Object Vdoc_directory;
526a2be7 2184extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
3cfe6dfd 2185
3cfe6dfd
JB
2186/* defined in doc.c */
2187extern Lisp_Object Vdoc_file_name;
2f69f2ec
RS
2188EXFUN (Fsubstitute_command_keys, 1);
2189EXFUN (Fdocumentation, 2);
2190EXFUN (Fdocumentation_property, 3);
2191extern Lisp_Object read_doc_string P_ ((Lisp_Object));
3cfe6dfd
JB
2192
2193/* defined in bytecode.c */
2194extern Lisp_Object Qbytecode;
2f69f2ec 2195EXFUN (Fbyte_code, 3);
3cfe6dfd
JB
2196
2197/* defined in macros.c */
2198extern Lisp_Object Qexecute_kbd_macro;
2f69f2ec 2199EXFUN (Fexecute_kbd_macro, 2);
3cfe6dfd 2200
d20c2151 2201/* defined in undo.c */
a387611b 2202extern Lisp_Object Qinhibit_read_only;
2f69f2ec
RS
2203EXFUN (Fundo_boundary, 0);
2204extern Lisp_Object truncate_undo_list P_ ((Lisp_Object, int, int));
526a2be7
AS
2205extern void record_marker_adjustment P_ ((Lisp_Object, int));
2206extern void record_insert P_ ((int, int));
2207extern void record_delete P_ ((int, int));
2208extern void record_first_change P_ ((void));
2209extern void record_change P_ ((int, int));
2210extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
2211 Lisp_Object));
d20c2151 2212
8537f1cb 2213/* defined in textprop.c */
c2d8811c 2214extern Lisp_Object Qmodification_hooks;
23bc39b5 2215extern Lisp_Object Qrear_nonsticky, Qfont;
c2d8811c 2216extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
2f69f2ec
RS
2217EXFUN (Fnext_property_change, 3);
2218EXFUN (Fnext_single_property_change, 4);
2219EXFUN (Fprevious_single_property_change, 4);
2220EXFUN (Fget_text_property, 3);
2221EXFUN (Fput_text_property, 5);
2222EXFUN (Fset_text_properties, 4);
2223EXFUN (Ftext_property_not_all, 5);
2224EXFUN (Fprevious_char_property_change, 2);
2225EXFUN (Fnext_char_property_change, 2);
526a2be7 2226extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
8537f1cb 2227
40131ef5 2228/* defined in intervals.c */
2f69f2ec 2229extern Lisp_Object get_local_map P_ ((int, struct buffer *));
40131ef5
KH
2230
2231/* defined in xmenu.c */
2f69f2ec
RS
2232EXFUN (Fx_popup_menu, 2);
2233EXFUN (Fx_popup_dialog, 2);
526a2be7
AS
2234
2235/* defined in sysdep.c */
2236extern void init_sigio P_ ((int));
2237extern void request_sigio P_ ((void));
2238extern void unrequest_sigio P_ ((void));
2239extern void reset_sys_modes P_ ((void));
2240extern void sys_subshell P_ ((void));
2241extern void sys_suspend P_ ((void));
2242extern void discard_tty_input P_ ((void));
2243extern void init_sys_modes P_ ((void));
2244extern void reset_sys_modes P_ ((void));
2245extern void get_frame_size P_ ((int *, int *));
2246extern void wait_for_termination P_ ((int));
2247extern void flush_pending_output P_ ((int));
2248extern void child_setup_tty P_ ((int));
2249extern void setup_pty P_ ((int));
2250extern int set_window_size P_ ((int, int, int));
2251extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
2252extern int tabs_safe_p P_ ((void));
2253extern void init_baud_rate P_ ((void));
2254
2255/* defined in filelock.c */
2256EXFUN (Funlock_buffer, 0);
2257extern void unlock_all_files P_ ((void));
2258extern void lock_file P_ ((Lisp_Object));
2259extern void unlock_file P_ ((Lisp_Object));
2260extern void unlock_buffer P_ ((struct buffer *));
40131ef5 2261\f
3cfe6dfd
JB
2262/* Nonzero means Emacs has already been initialized.
2263 Used during startup to detect startup of dumped Emacs. */
2264extern int initialized;
2265
2266extern int immediate_quit; /* Nonzero means ^G can quit instantly */
2267
339747e4 2268extern char *getenv (), *ctime (), *getwd ();
3cfe6dfd 2269extern long *xmalloc (), *xrealloc ();
9ac0d9e0 2270extern void xfree ();
3cfe6dfd 2271
526a2be7 2272extern char *egetenv P_ ((char *));
e98227af 2273
5d6be39f 2274/* Set up the name of the machine we're running on. */
526a2be7 2275extern void init_system_name P_ ((void));
881a5a80
RS
2276
2277/* Some systems (e.g., NT) use a different path separator than Unix,
2278 in addition to a device separator. Default the path separator
2279 to '/', and don't test for a device separator in IS_ANY_SEP. */
2280
e0c07012
RS
2281#ifdef WINDOWSNT
2282extern Lisp_Object Vdirectory_sep_char;
2283#endif
2284
881a5a80
RS
2285#ifndef DIRECTORY_SEP
2286#define DIRECTORY_SEP '/'
2287#endif
881a5a80
RS
2288#ifndef IS_DIRECTORY_SEP
2289#define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
2290#endif
2291#ifndef IS_DEVICE_SEP
2292#ifndef DEVICE_SEP
2293#define IS_DEVICE_SEP(_c_) 0
2294#else
2295#define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
2296#endif
2297#endif
2298#ifndef IS_ANY_SEP
2299#define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
2300#endif
51bd4610
KH
2301
2302#ifdef SWITCH_ENUM_BUG
2303#define SWITCH_ENUM_CAST(x) ((int)(x))
2304#else
2305#define SWITCH_ENUM_CAST(x) (x)
2306#endif