HCoop / bpt / emacs.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
(redisplay_preserve_echo_area): Add parameter
[bpt/emacs.git] / src / lisp.h
... / ...
CommitLineData
1/* Fundamental definitions for GNU Emacs Lisp interpreter.
2 Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000, 2001
3 Free Software Foundation, Inc.
4
5This file is part of GNU Emacs.
6
7GNU Emacs is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GNU Emacs is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GNU Emacs; see the file COPYING. If not, write to
19the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20Boston, MA 02111-1307, USA. */
21
22/* Declare the prototype for a general external function. */
23#if defined (PROTOTYPES) || defined (WINDOWSNT)
24#define P_(proto) proto
25#else
26#define P_(proto) ()
27#endif
28
29/* Define this temporarily to hunt a bug. If defined, the size of
30 strings is redundantly recorded in sdata structures so that it can
31 be compared to the sizes recorded in Lisp strings. */
32
33#define GC_CHECK_STRING_BYTES 1
34
35
36/* These are default choices for the types to use. */
37#ifdef _LP64
38#ifndef EMACS_INT
39#define EMACS_INT long
40#define BITS_PER_EMACS_INT BITS_PER_LONG
41#endif
42#ifndef EMACS_UINT
43#define EMACS_UINT unsigned long
44#endif
45#else /* not _LP64 */
46#ifndef EMACS_INT
47#define EMACS_INT int
48#define BITS_PER_EMACS_INT BITS_PER_INT
49#endif
50#ifndef EMACS_UINT
51#define EMACS_UINT unsigned int
52#endif
53#endif
54
55/* Extra internal type checking? */
56extern int suppress_checking;
57extern void die P_((const char *, const char *, int));
58
59#ifdef ENABLE_CHECKING
60
61#define CHECK(check,msg) ((check || suppress_checking \
62 ? (void) 0 \
63 : die (msg, __FILE__, __LINE__)), \
64 0)
65
66/* Let's get some compile-time checking too. */
67#undef NO_UNION_TYPE
68
69#else
70
71/* Produce same side effects and result, but don't complain. */
72#define CHECK(check,msg) ((check),0)
73
74#endif
75
76/* Used for making sure that Emacs is compilable in all
77 conigurations. */
78
79#ifdef USE_LISP_UNION_TYPE
80#undef NO_UNION_TYPE
81#endif
82
83/* Define an Emacs version of "assert", since some system ones are
84 flaky. */
85#ifndef ENABLE_CHECKING
86#define eassert(X) (void) 0
87#else /* ENABLE_CHECKING */
88#if defined (__GNUC__) && __GNUC__ >= 2 && defined (__STDC__)
89#define eassert(cond) CHECK(cond,"assertion failed: " #cond)
90#else
91#define eassert(cond) CHECK(cond,"assertion failed")
92#endif
93#endif /* ENABLE_CHECKING */
94
95/* Define the fundamental Lisp data structures. */
96
97/* This is the set of Lisp data types. */
98
99enum Lisp_Type
100 {
101 /* Integer. XINT (obj) is the integer value. */
102 Lisp_Int,
103
104 /* Symbol. XSYMBOL (object) points to a struct Lisp_Symbol. */
105 Lisp_Symbol,
106
107 /* Miscellaneous. XMISC (object) points to a union Lisp_Misc,
108 whose first member indicates the subtype. */
109 Lisp_Misc,
110
111 /* String. XSTRING (object) points to a struct Lisp_String.
112 The length of the string, and its contents, are stored therein. */
113 Lisp_String,
114
115 /* Vector of Lisp objects, or something resembling it.
116 XVECTOR (object) points to a struct Lisp_Vector, which contains
117 the size and contents. The size field also contains the type
118 information, if it's not a real vector object. */
119 Lisp_Vectorlike,
120
121 /* Cons. XCONS (object) points to a struct Lisp_Cons. */
122 Lisp_Cons,
123
124 Lisp_Float,
125
126 /* This is not a type code. It is for range checking. */
127 Lisp_Type_Limit
128 };
129
130/* This is the set of datatypes that share a common structure.
131 The first member of the structure is a type code from this set.
132 The enum values are arbitrary, but we'll use large numbers to make it
133 more likely that we'll spot the error if a random word in memory is
134 mistakenly interpreted as a Lisp_Misc. */
135enum Lisp_Misc_Type
136 {
137 Lisp_Misc_Free = 0x5eab,
138 Lisp_Misc_Marker,
139 Lisp_Misc_Intfwd,
140 Lisp_Misc_Boolfwd,
141 Lisp_Misc_Objfwd,
142 Lisp_Misc_Buffer_Objfwd,
143 Lisp_Misc_Buffer_Local_Value,
144 Lisp_Misc_Some_Buffer_Local_Value,
145 Lisp_Misc_Overlay,
146 Lisp_Misc_Kboard_Objfwd,
147 /* Currently floats are not a misc type,
148 but let's define this in case we want to change that. */
149 Lisp_Misc_Float,
150 /* This is not a type code. It is for range checking. */
151 Lisp_Misc_Limit
152 };
153
154/* These values are overridden by the m- file on some machines. */
155#ifndef VALBITS
156#define VALBITS (BITS_PER_EMACS_INT - 4)
157#endif
158
159#ifndef GCTYPEBITS
160#define GCTYPEBITS 3
161#endif
162
163#if 0 /* This doesn't work on some systems that don't allow enumerators
164 > INT_MAX, and it won't work for long long EMACS_INT. These
165 values are now found in emacs.c as EMACS_INT variables. */
166
167/* Make these values available in GDB, which sees enums but not macros. */
168
169enum gdb_lisp_params
170{
171 gdb_valbits = VALBITS,
172 gdb_gctypebits = GCTYPEBITS,
173 gdb_emacs_intbits = sizeof (EMACS_INT) * BITS_PER_CHAR,
174#ifdef DATA_SEG_BITS
175 gdb_data_seg_bits = DATA_SEG_BITS
176#else
177 gdb_data_seg_bits = 0
178#endif
179};
180
181#endif /* 0 */
182
183#ifndef NO_UNION_TYPE
184
185#ifndef WORDS_BIG_ENDIAN
186
187/* Definition of Lisp_Object for little-endian machines. */
188
189typedef
190union Lisp_Object
191 {
192 /* Used for comparing two Lisp_Objects;
193 also, positive integers can be accessed fast this way. */
194 EMACS_INT i;
195
196 struct
197 {
198 EMACS_INT val : VALBITS;
199 EMACS_INT type : GCTYPEBITS + 1;
200 } s;
201 struct
202 {
203 EMACS_UINT val : VALBITS;
204 EMACS_INT type : GCTYPEBITS + 1;
205 } u;
206 struct
207 {
208 EMACS_UINT val : VALBITS;
209 enum Lisp_Type type : GCTYPEBITS;
210 /* The markbit is not really part of the value of a Lisp_Object,
211 and is always zero except during garbage collection. */
212 EMACS_UINT markbit : 1;
213 } gu;
214 }
215Lisp_Object;
216
217#else /* If WORDS_BIG_ENDIAN */
218
219typedef
220union Lisp_Object
221 {
222 /* Used for comparing two Lisp_Objects;
223 also, positive integers can be accessed fast this way. */
224 EMACS_INT i;
225
226 struct
227 {
228 EMACS_INT type : GCTYPEBITS+1;
229 EMACS_INT val : VALBITS;
230 } s;
231 struct
232 {
233 EMACS_INT type : GCTYPEBITS+1;
234 EMACS_UINT val : VALBITS;
235 } u;
236 struct
237 {
238 /* The markbit is not really part of the value of a Lisp_Object,
239 and is always zero except during garbage collection. */
240 EMACS_UINT markbit : 1;
241 enum Lisp_Type type : GCTYPEBITS;
242 EMACS_UINT val : VALBITS;
243 } gu;
244 }
245Lisp_Object;
246
247#endif /* WORDS_BIG_ENDIAN */
248
249#endif /* NO_UNION_TYPE */
250
251
252/* If union type is not wanted, define Lisp_Object as just a number. */
253
254#ifdef NO_UNION_TYPE
255#define Lisp_Object EMACS_INT
256#endif /* NO_UNION_TYPE */
257
258#ifndef VALMASK
259#define VALMASK ((((EMACS_INT) 1)<<VALBITS) - 1)
260#endif
261#define GCTYPEMASK ((((EMACS_INT) 1)<<GCTYPEBITS) - 1)
262
263/* Two flags that are set during GC. On some machines, these flags
264 are defined differently by the m- file. */
265
266/* This is set in the car of a cons and in the plist slot of a symbol
267 to indicate it is marked. Likewise in the plist slot of an interval,
268 the chain slot of a marker, the type slot of a float, and the name
269 slot of a buffer.
270
271 In strings, this bit in the size field indicates that the string
272 is a "large" one, one which was separately malloc'd
273 rather than being part of a string block. */
274
275#ifndef MARKBIT
276#define MARKBIT ((EMACS_INT) ((EMACS_UINT) 1 << (VALBITS + GCTYPEBITS)))
277#endif /*MARKBIT */
278
279/* In the size word of a vector, this bit means the vector has been marked.
280 In the size word of a large string, likewise. */
281
282#ifndef ARRAY_MARK_FLAG
283#define ARRAY_MARK_FLAG ((MARKBIT >> 1) & ~MARKBIT)
284#endif /* no ARRAY_MARK_FLAG */
285
286/* In the size word of a struct Lisp_Vector, this bit means it's really
287 some other vector-like object. */
288#ifndef PSEUDOVECTOR_FLAG
289#define PSEUDOVECTOR_FLAG ((ARRAY_MARK_FLAG >> 1) & ~ARRAY_MARK_FLAG)
290#endif
291
292/* In a pseudovector, the size field actually contains a word with one
293 PSEUDOVECTOR_FLAG bit set, and exactly one of the following bits to
294 indicate the actual type. */
295enum pvec_type
296{
297 PVEC_NORMAL_VECTOR = 0,
298 PVEC_PROCESS = 0x200,
299 PVEC_FRAME = 0x400,
300 PVEC_COMPILED = 0x800,
301 PVEC_WINDOW = 0x1000,
302 PVEC_WINDOW_CONFIGURATION = 0x2000,
303 PVEC_SUBR = 0x4000,
304 PVEC_CHAR_TABLE = 0x8000,
305 PVEC_BOOL_VECTOR = 0x10000,
306 PVEC_BUFFER = 0x20000,
307 PVEC_HASH_TABLE = 0x40000,
308 PVEC_TYPE_MASK = 0x7fe00
309
310#if 0 /* This is used to make the value of PSEUDOVECTOR_FLAG available to
311 GDB. It doesn't work on OS Alpha. Moved to a variable in
312 emacs.c. */
313 PVEC_FLAG = PSEUDOVECTOR_FLAG
314#endif
315};
316
317/* For convenience, we also store the number of elements in these bits. */
318#define PSEUDOVECTOR_SIZE_MASK 0x1ff
319\f
320/* These macros extract various sorts of values from a Lisp_Object.
321 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
322 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons. */
323
324#ifdef NO_UNION_TYPE
325
326/* One need to override this if there must be high bits set in data space
327 (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
328 on all machines, but would penalise machines which don't need it)
329 */
330#ifndef XTYPE
331#define XTYPE(a) ((enum Lisp_Type) ((a) >> VALBITS))
332#endif
333
334#ifndef XSETTYPE
335#define XSETTYPE(a, b) ((a) = XUINT (a) | ((EMACS_INT)(b) << VALBITS))
336#endif
337
338/* For integers known to be positive, XFASTINT provides fast retrieval
339 and XSETFASTINT provides fast storage. This takes advantage of the
340 fact that Lisp_Int is 0. */
341#define XFASTINT(a) ((a) + 0)
342#define XSETFASTINT(a, b) ((a) = (b))
343
344/* Extract the value of a Lisp_Object as a signed integer. */
345
346#ifndef XINT /* Some machines need to do this differently. */
347#define XINT(a) ((EMACS_INT) (((a) << (BITS_PER_EMACS_INT - VALBITS)) \
348 >> (BITS_PER_EMACS_INT - VALBITS)))
349#endif
350
351/* Extract the value as an unsigned integer. This is a basis
352 for extracting it as a pointer to a structure in storage. */
353
354#ifndef XUINT
355#define XUINT(a) ((EMACS_UINT) ((a) & VALMASK))
356#endif
357
358#ifndef XPNTR
359#ifdef HAVE_SHM
360/* In this representation, data is found in two widely separated segments. */
361extern int pure_size;
362#define XPNTR(a) \
363 (XUINT (a) | (XUINT (a) > pure_size ? DATA_SEG_BITS : PURE_SEG_BITS))
364#else /* not HAVE_SHM */
365#ifdef DATA_SEG_BITS
366/* This case is used for the rt-pc.
367 In the diffs I was given, it checked for ptr = 0
368 and did not adjust it in that case.
369 But I don't think that zero should ever be found
370 in a Lisp object whose data type says it points to something. */
371#define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
372#else
373#define XPNTR(a) XUINT (a)
374#endif
375#endif /* not HAVE_SHM */
376#endif /* no XPNTR */
377
378#ifndef XSET
379#define XSET(var, type, ptr) \
380 ((var) = ((EMACS_INT)(type) << VALBITS) + ((EMACS_INT) (ptr) & VALMASK))
381#endif
382
383/* Convert a C integer into a Lisp_Object integer. */
384
385#define make_number(N) \
386 ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
387
388/* During garbage collection, XGCTYPE must be used for extracting types
389 so that the mark bit is ignored. XMARKBIT accesses the markbit.
390 Markbits are used only in particular slots of particular structure types.
391 Other markbits are always zero.
392 Outside of garbage collection, all mark bits are always zero. */
393
394#ifndef XGCTYPE
395#define XGCTYPE(a) ((enum Lisp_Type) (((a) >> VALBITS) & GCTYPEMASK))
396#endif
397
398#if VALBITS + GCTYPEBITS == BITS_PER_EMACS_INT - 1
399/* Make XMARKBIT faster if mark bit is sign bit. */
400#ifndef XMARKBIT
401#define XMARKBIT(a) ((a) < 0)
402#endif
403#endif /* markbit is sign bit */
404
405#ifndef XMARKBIT
406#define XMARKBIT(a) ((a) & MARKBIT)
407#endif
408
409#ifndef XSETMARKBIT
410#define XSETMARKBIT(a,b) ((a) = ((a) & ~MARKBIT) | ((b) ? MARKBIT : 0))
411#endif
412
413#ifndef XMARK
414#define XMARK(a) ((a) |= MARKBIT)
415#endif
416
417#ifndef XUNMARK
418#define XUNMARK(a) ((a) &= ~MARKBIT)
419#endif
420
421#endif /* NO_UNION_TYPE */
422
423#ifndef NO_UNION_TYPE
424
425#define XTYPE(a) ((enum Lisp_Type) (a).u.type)
426#define XSETTYPE(a, b) ((a).u.type = (char) (b))
427
428/* For integers known to be positive, XFASTINT provides fast retrieval
429 and XSETFASTINT provides fast storage. This takes advantage of the
430 fact that Lisp_Int is 0. */
431#define XFASTINT(a) ((a).i + 0)
432#define XSETFASTINT(a, b) ((a).i = (b))
433
434#ifdef EXPLICIT_SIGN_EXTEND
435/* Make sure we sign-extend; compilers have been known to fail to do so. */
436#define XINT(a) (((a).i << (BITS_PER_EMACS_INT - VALBITS)) \
437 >> (BITS_PER_EMACS_INT - VALBITS))
438#else
439#define XINT(a) ((a).s.val)
440#endif /* EXPLICIT_SIGN_EXTEND */
441
442#define XUINT(a) ((a).u.val)
443#define XPNTR(a) ((a).u.val)
444
445#define XSET(var, vartype, ptr) \
446 (((var).s.val = ((EMACS_INT) (ptr))), ((var).s.type = ((char) (vartype))))
447
448#if __GNUC__ >= 2 && defined (__OPTIMIZE__)
449#define make_number(N) \
450 (__extension__ ({ Lisp_Object _l; _l.s.val = (N); _l.s.type = Lisp_Int; _l; }))
451#else
452extern Lisp_Object make_number ();
453#endif
454
455/* During garbage collection, XGCTYPE must be used for extracting types
456 so that the mark bit is ignored. XMARKBIT access the markbit.
457 Markbits are used only in particular slots of particular structure types.
458 Other markbits are always zero.
459 Outside of garbage collection, all mark bits are always zero. */
460
461#define XGCTYPE(a) ((a).gu.type)
462#define XMARKBIT(a) ((a).gu.markbit)
463#define XSETMARKBIT(a,b) (XMARKBIT(a) = (b))
464#define XMARK(a) (XMARKBIT(a) = 1)
465#define XUNMARK(a) (XMARKBIT(a) = 0)
466
467#endif /* NO_UNION_TYPE */
468
469/* Extract a value or address from a Lisp_Object. */
470
471#define XCONS(a) (eassert (GC_CONSP(a)),(struct Lisp_Cons *) XPNTR(a))
472#define XVECTOR(a) ((struct Lisp_Vector *) XPNTR(a))
473#define XSTRING(a) (eassert (GC_STRINGP(a)),(struct Lisp_String *) XPNTR(a))
474#define XSYMBOL(a) (eassert (GC_SYMBOLP(a)),(struct Lisp_Symbol *) XPNTR(a))
475#define XFLOAT(a) (eassert (GC_FLOATP(a)),(struct Lisp_Float *) XPNTR(a))
476
477/* Misc types. */
478
479#define XMISC(a) ((union Lisp_Misc *) XPNTR(a))
480#define XMISCTYPE(a) (XMARKER (a)->type)
481#define XMARKER(a) (&(XMISC(a)->u_marker))
482#define XINTFWD(a) (&(XMISC(a)->u_intfwd))
483#define XBOOLFWD(a) (&(XMISC(a)->u_boolfwd))
484#define XOBJFWD(a) (&(XMISC(a)->u_objfwd))
485#define XBUFFER_OBJFWD(a) (&(XMISC(a)->u_buffer_objfwd))
486#define XBUFFER_LOCAL_VALUE(a) (&(XMISC(a)->u_buffer_local_value))
487#define XOVERLAY(a) (&(XMISC(a)->u_overlay))
488#define XKBOARD_OBJFWD(a) (&(XMISC(a)->u_kboard_objfwd))
489
490/* Pseudovector types. */
491
492#define XPROCESS(a) (eassert (GC_PROCESSP(a)),(struct Lisp_Process *) XPNTR(a))
493#define XWINDOW(a) (eassert (GC_WINDOWP(a)),(struct window *) XPNTR(a))
494#define XSUBR(a) (eassert (GC_SUBRP(a)),(struct Lisp_Subr *) XPNTR(a))
495#define XBUFFER(a) (eassert (GC_BUFFERP(a)),(struct buffer *) XPNTR(a))
496#define XCHAR_TABLE(a) ((struct Lisp_Char_Table *) XPNTR(a))
497#define XBOOL_VECTOR(a) ((struct Lisp_Bool_Vector *) XPNTR(a))
498
499/* Construct a Lisp_Object from a value or address. */
500
501#define XSETINT(a, b) XSET (a, Lisp_Int, b)
502#define XSETCONS(a, b) XSET (a, Lisp_Cons, b)
503#define XSETVECTOR(a, b) XSET (a, Lisp_Vectorlike, b)
504#define XSETSTRING(a, b) XSET (a, Lisp_String, b)
505#define XSETSYMBOL(a, b) XSET (a, Lisp_Symbol, b)
506#define XSETFLOAT(a, b) XSET (a, Lisp_Float, b)
507
508/* Misc types. */
509
510#define XSETMISC(a, b) XSET (a, Lisp_Misc, b)
511#define XSETMARKER(a, b) (XSETMISC (a, b), XMISCTYPE (a) = Lisp_Misc_Marker)
512
513/* Pseudovector types. */
514
515#define XSETPSEUDOVECTOR(a, b, code) \
516 (XSETVECTOR (a, b), XVECTOR (a)->size |= PSEUDOVECTOR_FLAG | (code))
517#define XSETWINDOW_CONFIGURATION(a, b) \
518 (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
519#define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
520#define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
521#define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
522#define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
523#define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
524#define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
525#define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
526
527/* Convenience macros for dealing with Lisp arrays. */
528
529#define AREF(ARRAY, IDX) XVECTOR ((ARRAY))->contents[IDX]
530#define ASET(ARRAY, IDX, VAL) (AREF ((ARRAY), (IDX)) = (VAL))
531#define ASIZE(ARRAY) XVECTOR ((ARRAY))->size
532
533\f
534/* Basic data type for use of intervals. See the macros in intervals.h. */
535
536struct interval
537{
538 /* The first group of entries deal with the tree structure. */
539
540 unsigned int total_length; /* Length of myself and both children. */
541 unsigned int position; /* Cache of interval's character position. */
542 /* This field is usually updated
543 simultaneously with an interval
544 traversal, there is no guaranty
545 that it is valid for a random
546 interval. */
547 struct interval *left; /* Intervals which precede me. */
548 struct interval *right; /* Intervals which succeed me. */
549
550 /* Parent in the tree, or the Lisp_Object containing this interval tree.
551
552 The mark bit on the root interval of an interval tree says
553 whether we have started (and possibly finished) marking the
554 tree. If GC comes across an interval tree whose root's parent
555 field has its markbit set, it leaves the tree alone.
556
557 You'd think we could store this information in the parent object
558 somewhere (after all, that should be visited once and then
559 ignored too, right?), but strings are GC'd strangely. */
560 union
561 {
562 struct interval *interval;
563 Lisp_Object obj;
564 } up;
565 unsigned int up_obj : 1;
566
567 /* The remaining components are `properties' of the interval.
568 The first four are duplicates for things which can be on the list,
569 for purposes of speed. */
570
571 unsigned int write_protect : 1; /* Non-zero means can't modify. */
572 unsigned int visible : 1; /* Zero means don't display. */
573 unsigned int front_sticky : 1; /* Non-zero means text inserted just
574 before this interval goes into it. */
575 unsigned int rear_sticky : 1; /* Likewise for just after it. */
576
577 /* Properties of this interval.
578 The mark bit on this field says whether this particular interval
579 tree node has been visited. Since intervals should never be
580 shared, GC aborts if it seems to have visited an interval twice. */
581 Lisp_Object plist;
582};
583
584typedef struct interval *INTERVAL;
585
586/* Complain if object is not string or buffer type */
587#define CHECK_STRING_OR_BUFFER(x, i) \
588 { if (!STRINGP ((x)) && !BUFFERP ((x))) \
589 x = wrong_type_argument (Qbuffer_or_string_p, (x)); }
590\f
591/* In a cons, the markbit of the car is the gc mark bit */
592
593struct Lisp_Cons
594 {
595 /* Please do not use the names of these elements in code other
596 than the core lisp implementation. Use XCAR and XCDR below. */
597#ifdef HIDE_LISP_IMPLEMENTATION
598 Lisp_Object car_, cdr_;
599#else
600 Lisp_Object car, cdr;
601#endif
602 };
603
604/* Take the car or cdr of something known to be a cons cell. */
605#ifdef HIDE_LISP_IMPLEMENTATION
606#define XCAR(c) (XCONS ((c))->car_)
607#define XCDR(c) (XCONS ((c))->cdr_)
608#else
609#define XCAR(c) (XCONS ((c))->car)
610#define XCDR(c) (XCONS ((c))->cdr)
611#endif
612
613/* Take the car or cdr of something whose type is not known. */
614#define CAR(c) \
615 (CONSP ((c)) ? XCAR ((c)) \
616 : NILP ((c)) ? Qnil \
617 : wrong_type_argument (Qlistp, (c)))
618
619#define CDR(c) \
620 (CONSP ((c)) ? XCDR ((c)) \
621 : NILP ((c)) ? Qnil \
622 : wrong_type_argument (Qlistp, (c)))
623
624/* Nonzero if STR is a multibyte string. */
625#define STRING_MULTIBYTE(STR) \
626 (XSTRING (STR)->size_byte >= 0)
627
628/* Return the length in bytes of STR. */
629
630#ifdef GC_CHECK_STRING_BYTES
631
632struct Lisp_String;
633extern int string_bytes P_ ((struct Lisp_String *));
634#define STRING_BYTES(S) string_bytes ((S))
635
636#else /* not GC_CHECK_STRING_BYTES */
637
638#define STRING_BYTES(STR) \
639 ((STR)->size_byte < 0 ? (STR)->size : (STR)->size_byte)
640
641#endif /* not GC_CHECK_STRING_BYTES */
642
643/* Set the length in bytes of STR. */
644#define SET_STRING_BYTES(STR, SIZE) ((STR)->size_byte = (SIZE))
645
646/* In a string or vector, the sign bit of the `size' is the gc mark bit */
647
648struct Lisp_String
649 {
650 EMACS_INT size;
651 EMACS_INT size_byte;
652 INTERVAL intervals; /* text properties in this string */
653 unsigned char *data;
654 };
655
656/* If a struct is made to look like a vector, this macro returns the length
657 of the shortest vector that would hold that struct. */
658#define VECSIZE(type) ((sizeof (type) - (sizeof (struct Lisp_Vector) \
659 - sizeof (Lisp_Object)) \
660 + sizeof(Lisp_Object) - 1) /* round up */ \
661 / sizeof (Lisp_Object))
662
663struct Lisp_Vector
664 {
665 EMACS_INT size;
666 struct Lisp_Vector *next;
667 Lisp_Object contents[1];
668 };
669
670/* A char table is a kind of vectorlike, with contents are like a
671 vector but with a few other slots. For some purposes, it makes
672 sense to handle a chartable with type struct Lisp_Vector. An
673 element of a char table can be any Lisp objects, but if it is a sub
674 char-table, we treat it a table that contains information of a
675 group of characters of the same charsets or a specific character of
676 a charset. A sub char-table has the same structure as a char table
677 except for that the former omits several slots at the tail. A sub
678 char table appears only in an element of a char table, and there's
679 no way to access it directly from Emacs Lisp program. */
680
681/* This is the number of slots that apply to characters or character
682 sets. The first 128 are for ASCII, the next 128 are for 8-bit
683 European characters, and the last 128 are for multibyte characters.
684 The first 256 are indexed by the code itself, but the last 128 are
685 indexed by (charset-id + 128). */
686#define CHAR_TABLE_ORDINARY_SLOTS 384
687
688/* This is the number of slots that apply to characters of ASCII and
689 8-bit Europeans only. */
690#define CHAR_TABLE_SINGLE_BYTE_SLOTS 256
691
692/* This is the number of slots that every char table must have. This
693 counts the ordinary slots and the top, defalt, parent, and purpose
694 slots. */
695#define CHAR_TABLE_STANDARD_SLOTS (CHAR_TABLE_ORDINARY_SLOTS + 4)
696
697/* This is the number of slots that apply to position-code-1 and
698 position-code-2 of a multibyte character at the 2nd and 3rd level
699 sub char tables respectively. */
700#define SUB_CHAR_TABLE_ORDINARY_SLOTS 128
701
702/* This is the number of slots that every sub char table must have.
703 This counts the ordinary slots and the top and defalt slot. */
704#define SUB_CHAR_TABLE_STANDARD_SLOTS (SUB_CHAR_TABLE_ORDINARY_SLOTS + 2)
705
706/* Return the number of "extra" slots in the char table CT. */
707
708#define CHAR_TABLE_EXTRA_SLOTS(CT) \
709 (((CT)->size & PSEUDOVECTOR_SIZE_MASK) - CHAR_TABLE_STANDARD_SLOTS)
710
711/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
712 and 8-bit Europeans characters. For these characters, do not check
713 validity of CT. Do not follow parent. */
714#define CHAR_TABLE_REF(CT, IDX) \
715 ((IDX) >= 0 && (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
716 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
717 ? XCHAR_TABLE (CT)->contents[IDX] \
718 : XCHAR_TABLE (CT)->defalt) \
719 : Faref (CT, make_number (IDX)))
720
721/* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
722 and 8-bit Europeans characters. However, if the result is nil,
723 return IDX.
724
725 For these characters, do not check validity of CT
726 and do not follow parent. */
727#define CHAR_TABLE_TRANSLATE(CT, IDX) \
728 ((IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS \
729 ? (!NILP (XCHAR_TABLE (CT)->contents[IDX]) \
730 ? XINT (XCHAR_TABLE (CT)->contents[IDX]) \
731 : IDX) \
732 : char_table_translate (CT, IDX))
733
734/* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
735 8-bit Europeans characters. Do not check validity of CT. */
736#define CHAR_TABLE_SET(CT, IDX, VAL) \
737 do { \
738 if (XFASTINT (IDX) < CHAR_TABLE_SINGLE_BYTE_SLOTS) \
739 XCHAR_TABLE (CT)->contents[XFASTINT (IDX)] = VAL; \
740 else \
741 Faset (CT, IDX, VAL); \
742 } while (0)
743
744struct Lisp_Char_Table
745 {
746 /* This is the vector's size field, which also holds the
747 pseudovector type information. It holds the size, too.
748 The size counts the top, defalt, purpose, and parent slots.
749 The last three are not counted if this is a sub char table. */
750 EMACS_INT size;
751 struct Lisp_Vector *next;
752 /* This holds a flag to tell if this is a top level char table (t)
753 or a sub char table (nil). */
754 Lisp_Object top;
755 /* This holds a default value,
756 which is used whenever the value for a specific character is nil. */
757 Lisp_Object defalt;
758 /* This holds an actual value of each element. A sub char table
759 has only SUB_CHAR_TABLE_ORDINARY_SLOTS number of elements. */
760 Lisp_Object contents[CHAR_TABLE_ORDINARY_SLOTS];
761
762 /* A sub char table doesn't has the following slots. */
763
764 /* This points to another char table, which we inherit from
765 when the value for a specific character is nil.
766 The `defalt' slot takes precedence over this. */
767 Lisp_Object parent;
768 /* This should be a symbol which says what kind of use
769 this char-table is meant for.
770 Typically now the values can be `syntax-table' and `display-table'. */
771 Lisp_Object purpose;
772 /* These hold additional data. */
773 Lisp_Object extras[1];
774 };
775
776/* A boolvector is a kind of vectorlike, with contents are like a string. */
777struct Lisp_Bool_Vector
778 {
779 /* This is the vector's size field. It doesn't have the real size,
780 just the subtype information. */
781 EMACS_INT vector_size;
782 struct Lisp_Vector *next;
783 /* This is the size in bits. */
784 EMACS_INT size;
785 /* This contains the actual bits, packed into bytes. */
786 unsigned char data[1];
787 };
788
789/* In a symbol, the markbit of the plist is used as the gc mark bit */
790
791struct Lisp_Symbol
792 {
793 struct Lisp_String *name;
794 Lisp_Object value;
795 Lisp_Object function;
796 Lisp_Object plist;
797 Lisp_Object obarray;
798 struct Lisp_Symbol *next; /* -> next symbol in this obarray bucket */
799 };
800
801/* This structure describes a built-in function.
802 It is generated by the DEFUN macro only.
803 defsubr makes it into a Lisp object.
804
805 This type is treated in most respects as a pseudovector,
806 but since we never dynamically allocate or free them,
807 we don't need a next-vector field. */
808
809struct Lisp_Subr
810 {
811 EMACS_INT size;
812 Lisp_Object (*function) ();
813 short min_args, max_args;
814 char *symbol_name;
815 char *prompt;
816 char *doc;
817 };
818
819\f
820/***********************************************************************
821 Hash Tables
822 ***********************************************************************/
823
824/* The structure of a Lisp hash table. */
825
826struct Lisp_Hash_Table
827{
828 /* Vector fields. The hash table code doesn't refer to these. */
829 EMACS_INT size;
830 struct Lisp_Vector *vec_next;
831
832 /* Function used to compare keys. */
833 Lisp_Object test;
834
835 /* Nil if table is non-weak. Otherwise a symbol describing the
836 weakness of the table. */
837 Lisp_Object weak;
838
839 /* When the table is resized, and this is an integer, compute the
840 new size by adding this to the old size. If a float, compute the
841 new size by multiplying the old size with this factor. */
842 Lisp_Object rehash_size;
843
844 /* Resize hash table when number of entries/ table size is >= this
845 ratio, a float. */
846 Lisp_Object rehash_threshold;
847
848 /* Number of key/value entries in the table. */
849 Lisp_Object count;
850
851 /* Vector of keys and values. The key of item I is found at index
852 2 * I, the value is found at index 2 * I + 1. */
853 Lisp_Object key_and_value;
854
855 /* Vector of hash codes.. If hash[I] is nil, this means that that
856 entry I is unused. */
857 Lisp_Object hash;
858
859 /* Vector used to chain entries. If entry I is free, next[I] is the
860 entry number of the next free item. If entry I is non-free,
861 next[I] is the index of the next entry in the collision chain. */
862 Lisp_Object next;
863
864 /* Index of first free entry in free list. */
865 Lisp_Object next_free;
866
867 /* Bucket vector. A non-nil entry is the index of the first item in
868 a collision chain. This vector's size can be larger than the
869 hash table size to reduce collisions. */
870 Lisp_Object index;
871
872 /* Next weak hash table if this is a weak hash table. The head
873 of the list is in Vweak_hash_tables. */
874 Lisp_Object next_weak;
875
876 /* User-supplied hash function, or nil. */
877 Lisp_Object user_hash_function;
878
879 /* User-supplied key comparison function, or nil. */
880 Lisp_Object user_cmp_function;
881
882 /* C function to compare two keys. */
883 int (* cmpfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object,
884 unsigned, Lisp_Object, unsigned));
885
886 /* C function to compute hash code. */
887 unsigned (* hashfn) P_ ((struct Lisp_Hash_Table *, Lisp_Object));
888};
889
890
891#define XHASH_TABLE(OBJ) \
892 ((struct Lisp_Hash_Table *) XPNTR (OBJ))
893
894#define XSET_HASH_TABLE(VAR, PTR) \
895 (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
896
897#define HASH_TABLE_P(OBJ) PSEUDOVECTORP (OBJ, PVEC_HASH_TABLE)
898#define GC_HASH_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_HASH_TABLE)
899
900#define CHECK_HASH_TABLE(x, i) \
901 do \
902 { \
903 if (!HASH_TABLE_P ((x))) \
904 x = wrong_type_argument (Qhash_table_p, (x)); \
905 } \
906 while (0)
907
908/* Default size for hash tables if not specified. */
909
910#define DEFAULT_HASH_SIZE 65
911
912/* Default threshold specifying when to resize a hash table. The
913 value gives the ratio of current entries in the hash table and the
914 size of the hash table. */
915
916#define DEFAULT_REHASH_THRESHOLD 0.8
917
918/* Default factor by which to increase the size of a hash table. */
919
920#define DEFAULT_REHASH_SIZE 1.5
921
922\f
923/* These structures are used for various misc types. */
924
925/* A miscellaneous object, when it's on the free list. */
926struct Lisp_Free
927 {
928 int type : 16; /* = Lisp_Misc_Free */
929 int spacer : 16;
930 union Lisp_Misc *chain;
931 };
932
933/* In a marker, the markbit of the chain field is used as the gc mark bit. */
934struct Lisp_Marker
935{
936 int type : 16; /* = Lisp_Misc_Marker */
937 int spacer : 15;
938 /* 1 means normal insertion at the marker's position
939 leaves the marker after the inserted text. */
940 unsigned int insertion_type : 1;
941 /* This is the buffer that the marker points into,
942 or 0 if it points nowhere. */
943 struct buffer *buffer;
944
945 /* The remaining fields are meaningless in a marker that
946 does not point anywhere. */
947
948 /* For markers that point somewhere,
949 this is used to chain of all the markers in a given buffer. */
950 Lisp_Object chain;
951 /* This is the char position where the marker points. */
952 int charpos;
953 /* This is the byte position. */
954 int bytepos;
955};
956
957/* Forwarding pointer to an int variable.
958 This is allowed only in the value cell of a symbol,
959 and it means that the symbol's value really lives in the
960 specified int variable. */
961struct Lisp_Intfwd
962 {
963 int type : 16; /* = Lisp_Misc_Intfwd */
964 int spacer : 16;
965 int *intvar;
966 };
967
968/* Boolean forwarding pointer to an int variable.
969 This is like Lisp_Intfwd except that the ostensible
970 "value" of the symbol is t if the int variable is nonzero,
971 nil if it is zero. */
972struct Lisp_Boolfwd
973 {
974 int type : 16; /* = Lisp_Misc_Boolfwd */
975 int spacer : 16;
976 int *boolvar;
977 };
978
979/* Forwarding pointer to a Lisp_Object variable.
980 This is allowed only in the value cell of a symbol,
981 and it means that the symbol's value really lives in the
982 specified variable. */
983struct Lisp_Objfwd
984 {
985 int type : 16; /* = Lisp_Misc_Objfwd */
986 int spacer : 16;
987 Lisp_Object *objvar;
988 };
989
990/* Like Lisp_Objfwd except that value lives in a slot in the
991 current buffer. Value is byte index of slot within buffer. */
992struct Lisp_Buffer_Objfwd
993 {
994 int type : 16; /* = Lisp_Misc_Buffer_Objfwd */
995 int spacer : 16;
996 int offset;
997 };
998
999/* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
1000 the symbol has buffer-local or frame-local bindings. (Exception:
1001 some buffer-local variables are built-in, with their values stored
1002 in the buffer structure itself. They are handled differently,
1003 using struct Lisp_Buffer_Objfwd.)
1004
1005 The `realvalue' slot holds the variable's current value, or a
1006 forwarding pointer to where that value is kept. This value is the
1007 one that corresponds to the loaded binding. To read or set the
1008 variable, you must first make sure the right binding is loaded;
1009 then you can access the value in (or through) `realvalue'.
1010
1011 `buffer' and `frame' are the buffer and frame for which the loaded
1012 binding was found. If those have changed, to make sure the right
1013 binding is loaded it is necessary to find which binding goes with
1014 the current buffer and selected frame, then load it. To load it,
1015 first unload the previous binding, then copy the value of the new
1016 binding into `realvalue' (or through it). Also update
1017 LOADED-BINDING to point to the newly loaded binding.
1018
1019 Lisp_Misc_Buffer_Local_Value and Lisp_Misc_Some_Buffer_Local_Value
1020 both use this kind of structure. With the former, merely setting
1021 the variable creates a local binding for the current buffer. With
1022 the latter, setting the variable does not do that; only
1023 make-local-variable does that. */
1024
1025struct Lisp_Buffer_Local_Value
1026 {
1027 int type : 16; /* = Lisp_Misc_Buffer_Local_Value
1028 or Lisp_Misc_Some_Buffer_Local_Value */
1029 int spacer : 13;
1030
1031 /* 1 means this variable is allowed to have frame-local bindings,
1032 so check for them when looking for the proper binding. */
1033 unsigned int check_frame : 1;
1034 /* 1 means that the binding now loaded was found
1035 as a local binding for the buffer in the `buffer' slot. */
1036 unsigned int found_for_buffer : 1;
1037 /* 1 means that the binding now loaded was found
1038 as a local binding for the frame in the `frame' slot. */
1039 unsigned int found_for_frame : 1;
1040 Lisp_Object realvalue;
1041 /* The buffer and frame for which the loaded binding was found. */
1042 Lisp_Object buffer, frame;
1043
1044 /* A cons cell, (LOADED-BINDING . DEFAULT-VALUE).
1045
1046 LOADED-BINDING is the binding now loaded. It is a cons cell
1047 whose cdr is the binding's value. The cons cell may be an
1048 element of a buffer's local-variable alist, or an element of a
1049 frame's parameter alist, or it may be this cons cell.
1050
1051 DEFAULT-VALUE is the variable's default value, seen when the
1052 current buffer and selected frame do not have their own
1053 bindings for the variable. When the default binding is loaded,
1054 LOADED-BINDING is actually this very cons cell; thus, its car
1055 points to itself. */
1056 Lisp_Object cdr;
1057 };
1058
1059/* In an overlay object, the mark bit of the plist is used as the GC mark.
1060 START and END are markers in the overlay's buffer, and
1061 PLIST is the overlay's property list. */
1062struct Lisp_Overlay
1063 {
1064 int type : 16; /* = Lisp_Misc_Overlay */
1065 int spacer : 16;
1066 Lisp_Object start, end, plist;
1067 };
1068
1069/* Like Lisp_Objfwd except that value lives in a slot in the
1070 current kboard. */
1071struct Lisp_Kboard_Objfwd
1072 {
1073 int type : 16; /* = Lisp_Misc_Kboard_Objfwd */
1074 int spacer : 16;
1075 int offset;
1076 };
1077
1078
1079/* To get the type field of a union Lisp_Misc, use XMISCTYPE.
1080 It uses one of these struct subtypes to get the type field. */
1081
1082union Lisp_Misc
1083 {
1084 struct Lisp_Free u_free;
1085 struct Lisp_Marker u_marker;
1086 struct Lisp_Intfwd u_intfwd;
1087 struct Lisp_Boolfwd u_boolfwd;
1088 struct Lisp_Objfwd u_objfwd;
1089 struct Lisp_Buffer_Objfwd u_buffer_objfwd;
1090 struct Lisp_Buffer_Local_Value u_buffer_local_value;
1091 struct Lisp_Overlay u_overlay;
1092 struct Lisp_Kboard_Objfwd u_kboard_objfwd;
1093 };
1094\f
1095/* Lisp floating point type */
1096struct Lisp_Float
1097 {
1098 Lisp_Object type; /* essentially used for mark-bit
1099 and chaining when on free-list */
1100#ifdef HIDE_LISP_IMPLEMENTATION
1101 double data_;
1102#else
1103 double data;
1104#endif
1105 };
1106
1107#ifdef HIDE_LISP_IMPLEMENTATION
1108#define XFLOAT_DATA(f) (XFLOAT (f)->data_)
1109#else
1110#define XFLOAT_DATA(f) (XFLOAT (f)->data)
1111#endif
1112
1113/* A character, declared with the following typedef, is a member
1114 of some character set associated with the current buffer. */
1115#ifndef _UCHAR_T /* Protect against something in ctab.h on AIX. */
1116#define _UCHAR_T
1117typedef unsigned char UCHAR;
1118#endif
1119
1120/* Meanings of slots in a Lisp_Compiled: */
1121
1122#define COMPILED_ARGLIST 0
1123#define COMPILED_BYTECODE 1
1124#define COMPILED_CONSTANTS 2
1125#define COMPILED_STACK_DEPTH 3
1126#define COMPILED_DOC_STRING 4
1127#define COMPILED_INTERACTIVE 5
1128
1129/* Flag bits in a character. These also get used in termhooks.h.
1130 Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
1131 (MUlti-Lingual Emacs) might need 22 bits for the character value
1132 itself, so we probably shouldn't use any bits lower than 0x0400000. */
1133#define CHAR_ALT (0x0400000)
1134#define CHAR_SUPER (0x0800000)
1135#define CHAR_HYPER (0x1000000)
1136#define CHAR_SHIFT (0x2000000)
1137#define CHAR_CTL (0x4000000)
1138#define CHAR_META (0x8000000)
1139
1140#define CHAR_MODIFIER_MASK \
1141 (CHAR_ALT | CHAR_SUPER | CHAR_HYPER | CHAR_SHIFT | CHAR_CTL | CHAR_META)
1142
1143
1144/* Actually, the current Emacs uses 19 bits for the character value
1145 itself. */
1146#define CHARACTERBITS 19
1147
1148/* The maximum byte size consumed by push_key_description.
1149 All callers should assure that at least this size of memory is
1150 allocated at the place pointed by the second argument.
1151
1152 Thers are 6 modifiers, each consumes 2 chars.
1153 The octal form of a character code consumes
1154 (1 + CHARACTERBITS / 3 + 1) chars (including backslash at the head).
1155 We need one more byte for string terminator `\0'. */
1156#define KEY_DESCRIPTION_SIZE ((2 * 6) + 1 + (CHARACTERBITS / 3) + 1 + 1)
1157
1158#ifdef USE_X_TOOLKIT
1159#ifdef NO_UNION_TYPE
1160/* Use this for turning a (void *) into a Lisp_Object, as when the
1161 Lisp_Object is passed into a toolkit callback function. */
1162#define VOID_TO_LISP(larg,varg) \
1163 do { ((larg) = ((Lisp_Object) (varg))); } while (0)
1164#define CVOID_TO_LISP VOID_TO_LISP
1165
1166/* Use this for turning a Lisp_Object into a (void *), as when the
1167 Lisp_Object is passed into a toolkit callback function. */
1168#define LISP_TO_VOID(larg) ((void *) (larg))
1169#define LISP_TO_CVOID(varg) ((const void *) (larg))
1170
1171#else /* not NO_UNION_TYPE */
1172/* Use this for turning a (void *) into a Lisp_Object, as when the
1173 Lisp_Object is passed into a toolkit callback function. */
1174#define VOID_TO_LISP(larg,varg) \
1175 do { ((larg).v = (void *) (varg)); } while (0)
1176#define CVOID_TO_LISP(larg,varg) \
1177 do { ((larg).cv = (const void *) (varg)); } while (0)
1178
1179/* Use this for turning a Lisp_Object into a (void *), as when the
1180 Lisp_Object is passed into a toolkit callback function. */
1181#define LISP_TO_VOID(larg) ((larg).v)
1182#define LISP_TO_CVOID(larg) ((larg).cv)
1183#endif /* not NO_UNION_TYPE */
1184#endif /* USE_X_TOOLKIT */
1185
1186\f
1187/* The glyph datatype, used to represent characters on the display. */
1188
1189/* Glyph code to use as an index to the glyph table. If it is out of
1190 range for the glyph table, or the corresonding element in the table
1191 is nil, the low 8 bits are the single byte character code, and the
1192 bits above are the numeric face ID. If FID is the face ID of a
1193 glyph on a frame F, then F->display.x->faces[FID] contains the
1194 description of that face. This is an int instead of a short, so we
1195 can support a good bunch of face ID's (2^(31 - 8)); given that we
1196 have no mechanism for tossing unused frame face ID's yet, we'll
1197 probably run out of 255 pretty quickly.
1198 This is always -1 for a multibyte character. */
1199#define GLYPH int
1200
1201/* Mask bits for face. */
1202#define GLYPH_MASK_FACE 0x7FF80000
1203 /* Mask bits for character code. */
1204#define GLYPH_MASK_CHAR 0x0007FFFF /* The lowest 19 bits */
1205
1206/* The FAST macros assume that we already know we're in an X window. */
1207
1208/* Set a character code and a face ID in a glyph G. */
1209#define FAST_MAKE_GLYPH(char, face) ((char) | ((face) << CHARACTERBITS))
1210
1211/* Return a glyph's character code. */
1212#define FAST_GLYPH_CHAR(glyph) ((glyph) & GLYPH_MASK_CHAR)
1213
1214/* Return a glyph's face ID. */
1215#define FAST_GLYPH_FACE(glyph) (((glyph) & GLYPH_MASK_FACE) >> CHARACTERBITS)
1216
1217/* Slower versions that test the frame type first. */
1218#define MAKE_GLYPH(f, char, face) (FAST_MAKE_GLYPH (char, face))
1219#define GLYPH_CHAR(f, g) (FAST_GLYPH_CHAR (g))
1220#define GLYPH_FACE(f, g) (FAST_GLYPH_FACE (g))
1221
1222/* Return 1 iff GLYPH contains valid character code. */
1223#define GLYPH_CHAR_VALID_P(glyph) \
1224 ((GLYPH) (FAST_GLYPH_CHAR (glyph)) <= MAX_CHAR)
1225
1226/* The ID of the mode line highlighting face. */
1227#define GLYPH_MODE_LINE_FACE 1
1228\f
1229/* Data type checking */
1230
1231#define NILP(x) (XFASTINT (x) == XFASTINT (Qnil))
1232#define GC_NILP(x) GC_EQ (x, Qnil)
1233
1234#define NUMBERP(x) (INTEGERP (x) || FLOATP (x))
1235#define GC_NUMBERP(x) (GC_INTEGERP (x) || GC_FLOATP (x))
1236#define NATNUMP(x) (INTEGERP (x) && XINT (x) >= 0)
1237#define GC_NATNUMP(x) (GC_INTEGERP (x) && XINT (x) >= 0)
1238
1239#define INTEGERP(x) (XTYPE ((x)) == Lisp_Int)
1240#define GC_INTEGERP(x) (XGCTYPE ((x)) == Lisp_Int)
1241#define SYMBOLP(x) (XTYPE ((x)) == Lisp_Symbol)
1242#define GC_SYMBOLP(x) (XGCTYPE ((x)) == Lisp_Symbol)
1243#define MISCP(x) (XTYPE ((x)) == Lisp_Misc)
1244#define GC_MISCP(x) (XGCTYPE ((x)) == Lisp_Misc)
1245#define VECTORLIKEP(x) (XTYPE ((x)) == Lisp_Vectorlike)
1246#define GC_VECTORLIKEP(x) (XGCTYPE ((x)) == Lisp_Vectorlike)
1247#define STRINGP(x) (XTYPE ((x)) == Lisp_String)
1248#define GC_STRINGP(x) (XGCTYPE ((x)) == Lisp_String)
1249#define CONSP(x) (XTYPE ((x)) == Lisp_Cons)
1250#define GC_CONSP(x) (XGCTYPE ((x)) == Lisp_Cons)
1251
1252#define FLOATP(x) (XTYPE ((x)) == Lisp_Float)
1253#define GC_FLOATP(x) (XGCTYPE ((x)) == Lisp_Float)
1254#define VECTORP(x) (VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1255#define GC_VECTORP(x) (GC_VECTORLIKEP (x) && !(XVECTOR (x)->size & PSEUDOVECTOR_FLAG))
1256#define OVERLAYP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1257#define GC_OVERLAYP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Overlay)
1258#define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1259#define GC_MARKERP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
1260#define INTFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1261#define GC_INTFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Intfwd)
1262#define BOOLFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1263#define GC_BOOLFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Boolfwd)
1264#define OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1265#define GC_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Objfwd)
1266#define BUFFER_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1267#define GC_BUFFER_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Objfwd)
1268#define BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1269#define GC_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Buffer_Local_Value)
1270#define SOME_BUFFER_LOCAL_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1271#define GC_SOME_BUFFER_LOCAL_VALUEP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Some_Buffer_Local_Value)
1272#define KBOARD_OBJFWDP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1273#define GC_KBOARD_OBJFWDP(x) (GC_MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Kboard_Objfwd)
1274
1275
1276/* True if object X is a pseudovector whose code is CODE. */
1277#define PSEUDOVECTORP(x, code) \
1278 (VECTORLIKEP (x) \
1279 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1280 == (PSEUDOVECTOR_FLAG | (code))))
1281
1282/* True if object X is a pseudovector whose code is CODE.
1283 This one works during GC. */
1284#define GC_PSEUDOVECTORP(x, code) \
1285 (GC_VECTORLIKEP (x) \
1286 && (((XVECTOR (x)->size & (PSEUDOVECTOR_FLAG | (code)))) \
1287 == (PSEUDOVECTOR_FLAG | (code))))
1288
1289/* Test for specific pseudovector types. */
1290#define WINDOW_CONFIGURATIONP(x) PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1291#define GC_WINDOW_CONFIGURATIONP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW_CONFIGURATION)
1292#define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
1293#define GC_PROCESSP(x) GC_PSEUDOVECTORP (x, PVEC_PROCESS)
1294#define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
1295#define GC_WINDOWP(x) GC_PSEUDOVECTORP (x, PVEC_WINDOW)
1296#define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
1297#define GC_SUBRP(x) GC_PSEUDOVECTORP (x, PVEC_SUBR)
1298#define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
1299#define GC_COMPILEDP(x) GC_PSEUDOVECTORP (x, PVEC_COMPILED)
1300#define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
1301#define GC_BUFFERP(x) GC_PSEUDOVECTORP (x, PVEC_BUFFER)
1302#define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1303#define GC_CHAR_TABLE_P(x) GC_PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
1304#define BOOL_VECTOR_P(x) PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1305#define GC_BOOL_VECTOR_P(x) GC_PSEUDOVECTORP (x, PVEC_BOOL_VECTOR)
1306#define FRAMEP(x) PSEUDOVECTORP (x, PVEC_FRAME)
1307#define GC_FRAMEP(x) GC_PSEUDOVECTORP (x, PVEC_FRAME)
1308
1309#define SUB_CHAR_TABLE_P(x) (CHAR_TABLE_P (x) && NILP (XCHAR_TABLE (x)->top))
1310\f
1311#define EQ(x, y) (XFASTINT (x) == XFASTINT (y))
1312#define GC_EQ(x, y) (XGCTYPE (x) == XGCTYPE (y) && XPNTR (x) == XPNTR (y))
1313
1314#define CHECK_LIST(x, i) \
1315 do { if (!CONSP ((x)) && !NILP (x)) x = wrong_type_argument (Qlistp, (x)); } while (0)
1316
1317#define CHECK_STRING(x, i) \
1318 do { if (!STRINGP ((x))) x = wrong_type_argument (Qstringp, (x)); } while (0)
1319
1320#define CHECK_CONS(x, i) \
1321 do { if (!CONSP ((x))) x = wrong_type_argument (Qconsp, (x)); } while (0)
1322
1323#define CHECK_SYMBOL(x, i) \
1324 do { if (!SYMBOLP ((x))) x = wrong_type_argument (Qsymbolp, (x)); } while (0)
1325
1326#define CHECK_CHAR_TABLE(x, i) \
1327 do { if (!CHAR_TABLE_P ((x))) \
1328 x = wrong_type_argument (Qchar_table_p, (x)); } while (0)
1329
1330#define CHECK_VECTOR(x, i) \
1331 do { if (!VECTORP ((x))) x = wrong_type_argument (Qvectorp, (x)); } while (0)
1332
1333#define CHECK_VECTOR_OR_CHAR_TABLE(x, i) \
1334 do { if (!VECTORP ((x)) && !CHAR_TABLE_P ((x))) \
1335 x = wrong_type_argument (Qvector_or_char_table_p, (x)); \
1336 } while (0)
1337
1338#define CHECK_BUFFER(x, i) \
1339 do { if (!BUFFERP ((x))) x = wrong_type_argument (Qbufferp, (x)); } while (0)
1340
1341#define CHECK_WINDOW(x, i) \
1342 do { if (!WINDOWP ((x))) x = wrong_type_argument (Qwindowp, (x)); } while (0)
1343
1344/* This macro rejects windows on the interior of the window tree as
1345 "dead", which is what we want; this is an argument-checking macro, and
1346 the user should never get access to interior windows.
1347
1348 A window of any sort, leaf or interior, is dead iff the buffer,
1349 vchild, and hchild members are all nil. */
1350
1351#define CHECK_LIVE_WINDOW(x, i) \
1352 do { \
1353 if (!WINDOWP ((x)) \
1354 || NILP (XWINDOW ((x))->buffer)) \
1355 x = wrong_type_argument (Qwindow_live_p, (x)); \
1356 } while (0)
1357
1358#define CHECK_PROCESS(x, i) \
1359 do { if (!PROCESSP ((x))) x = wrong_type_argument (Qprocessp, (x)); } while (0)
1360
1361#define CHECK_NUMBER(x, i) \
1362 do { if (!INTEGERP ((x))) x = wrong_type_argument (Qintegerp, (x)); } while (0)
1363
1364#define CHECK_NATNUM(x, i) \
1365 do { if (!NATNUMP (x)) x = wrong_type_argument (Qwholenump, (x)); } while (0)
1366
1367#define CHECK_MARKER(x, i) \
1368 do { if (!MARKERP ((x))) x = wrong_type_argument (Qmarkerp, (x)); } while (0)
1369
1370#define CHECK_NUMBER_COERCE_MARKER(x, i) \
1371 do { if (MARKERP ((x))) XSETFASTINT (x, marker_position (x)); \
1372 else if (!INTEGERP ((x))) x = wrong_type_argument (Qinteger_or_marker_p, (x)); } while (0)
1373
1374#define XFLOATINT(n) extract_float((n))
1375
1376#define CHECK_FLOAT(x, i) \
1377 do { if (!FLOATP (x)) \
1378 x = wrong_type_argument (Qfloatp, (x)); } while (0)
1379
1380#define CHECK_NUMBER_OR_FLOAT(x, i) \
1381 do { if (!FLOATP (x) && !INTEGERP (x)) \
1382 x = wrong_type_argument (Qnumberp, (x)); } while (0)
1383
1384#define CHECK_NUMBER_OR_FLOAT_COERCE_MARKER(x, i) \
1385 do { if (MARKERP (x)) XSETFASTINT (x, marker_position (x)); \
1386 else if (!INTEGERP (x) && !FLOATP (x)) \
1387 x = wrong_type_argument (Qnumber_or_marker_p, (x)); } while (0)
1388
1389#define CHECK_OVERLAY(x, i) \
1390 do { if (!OVERLAYP ((x))) x = wrong_type_argument (Qoverlayp, (x));} while (0)
1391
1392/* Cast pointers to this type to compare them. Some machines want int. */
1393#ifndef PNTR_COMPARISON_TYPE
1394#define PNTR_COMPARISON_TYPE EMACS_UINT
1395#endif
1396\f
1397/* Define a built-in function for calling from Lisp.
1398 `lname' should be the name to give the function in Lisp,
1399 as a null-terminated C string.
1400 `fnname' should be the name of the function in C.
1401 By convention, it starts with F.
1402 `sname' should be the name for the C constant structure
1403 that records information on this function for internal use.
1404 By convention, it should be the same as `fnname' but with S instead of F.
1405 It's too bad that C macros can't compute this from `fnname'.
1406 `minargs' should be a number, the minimum number of arguments allowed.
1407 `maxargs' should be a number, the maximum number of arguments allowed,
1408 or else MANY or UNEVALLED.
1409 MANY means pass a vector of evaluated arguments,
1410 in the form of an integer number-of-arguments
1411 followed by the address of a vector of Lisp_Objects
1412 which contains the argument values.
1413 UNEVALLED means pass the list of unevaluated arguments
1414 `prompt' says how to read arguments for an interactive call.
1415 See the doc string for `interactive'.
1416 A null string means call interactively with no arguments.
1417 `doc' is documentation for the user. */
1418
1419#if (!defined (__STDC__) && !defined (PROTOTYPES)) \
1420 || defined (USE_NONANSI_DEFUN)
1421#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1422 Lisp_Object fnname (); \
1423 struct Lisp_Subr sname = \
1424 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1425 fnname, minargs, maxargs, lname, prompt, 0}; \
1426 Lisp_Object fnname
1427
1428#else
1429
1430/* This version of DEFUN declares a function prototype with the right
1431 arguments, so we can catch errors with maxargs at compile-time. */
1432#define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc) \
1433 Lisp_Object fnname DEFUN_ARGS_ ## maxargs ; \
1434 struct Lisp_Subr sname = \
1435 { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)), \
1436 fnname, minargs, maxargs, lname, prompt, 0}; \
1437 Lisp_Object fnname
1438
1439/* Note that the weird token-substitution semantics of ANSI C makes
1440 this work for MANY and UNEVALLED. */
1441#define DEFUN_ARGS_MANY (int, Lisp_Object *)
1442#define DEFUN_ARGS_UNEVALLED (Lisp_Object)
1443#define DEFUN_ARGS_0 (void)
1444#define DEFUN_ARGS_1 (Lisp_Object)
1445#define DEFUN_ARGS_2 (Lisp_Object, Lisp_Object)
1446#define DEFUN_ARGS_3 (Lisp_Object, Lisp_Object, Lisp_Object)
1447#define DEFUN_ARGS_4 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1448#define DEFUN_ARGS_5 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1449 Lisp_Object)
1450#define DEFUN_ARGS_6 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1451 Lisp_Object, Lisp_Object)
1452#define DEFUN_ARGS_7 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1453 Lisp_Object, Lisp_Object, Lisp_Object)
1454#define DEFUN_ARGS_8 (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, \
1455 Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object)
1456#endif
1457
1458/* Non-zero if OBJ is a Lisp function. */
1459
1460#define FUNCTIONP(OBJ) \
1461 ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda)) \
1462 || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ))) \
1463 || COMPILEDP (OBJ) \
1464 || SUBRP (OBJ))
1465
1466/* defsubr (Sname);
1467 is how we define the symbol for function `name' at start-up time. */
1468extern void defsubr P_ ((struct Lisp_Subr *));
1469
1470#define MANY -2
1471#define UNEVALLED -1
1472
1473extern void defvar_lisp P_ ((char *, Lisp_Object *));
1474extern void defvar_lisp_nopro P_ ((char *, Lisp_Object *));
1475extern void defvar_bool P_ ((char *, int *));
1476extern void defvar_int P_ ((char *, int *));
1477extern void defvar_per_buffer P_ ((char *, Lisp_Object *, Lisp_Object, char *));
1478extern void defvar_kboard P_ ((char *, int));
1479
1480/* Macros we use to define forwarded Lisp variables.
1481 These are used in the syms_of_FILENAME functions. */
1482
1483#define DEFVAR_LISP(lname, vname, doc) defvar_lisp (lname, vname)
1484#define DEFVAR_LISP_NOPRO(lname, vname, doc) defvar_lisp_nopro (lname, vname)
1485#define DEFVAR_BOOL(lname, vname, doc) defvar_bool (lname, vname)
1486#define DEFVAR_INT(lname, vname, doc) defvar_int (lname, vname)
1487#define DEFVAR_PER_BUFFER(lname, vname, type, doc) \
1488 defvar_per_buffer (lname, vname, type, 0)
1489#define DEFVAR_KBOARD(lname, vname, doc) \
1490 defvar_kboard (lname, \
1491 (int)((char *)(&current_kboard->vname) \
1492 - (char *)current_kboard))
1493\f
1494/* Structure for recording Lisp call stack for backtrace purposes. */
1495
1496/* The special binding stack holds the outer values of variables while
1497 they are bound by a function application or a let form, stores the
1498 code to be executed for Lisp unwind-protect forms, and stores the C
1499 functions to be called for record_unwind_protect.
1500
1501 If func is non-zero, undoing this binding applies func to old_value;
1502 This implements record_unwind_protect.
1503 If func is zero and symbol is nil, undoing this binding evaluates
1504 the list of forms in old_value; this implements Lisp's unwind-protect
1505 form.
1506
1507 Otherwise, the element is a variable binding.
1508 If the symbol field is a symbol, it is an ordinary variable binding.
1509 Otherwise, it should be a structure (SYMBOL BUFFER . BUFFER),
1510 which represents having bound BUFFER's local value,
1511 or (SYMBOL nil . BUFFER), which represents having bound the default
1512 value when BUFFER was current (buffer not having any local binding
1513 for SYMBOL). */
1514
1515struct specbinding
1516 {
1517 Lisp_Object symbol, old_value;
1518 Lisp_Object (*func) P_ ((Lisp_Object));
1519 Lisp_Object unused; /* Dividing by 16 is faster than by 12 */
1520 };
1521
1522extern struct specbinding *specpdl;
1523extern struct specbinding *specpdl_ptr;
1524extern int specpdl_size;
1525
1526#define BINDING_STACK_SIZE() (specpdl_ptr - specpdl)
1527
1528/* Everything needed to describe an active condition case. */
1529struct handler
1530 {
1531 /* The handler clauses and variable from the condition-case form. */
1532 Lisp_Object handler;
1533 Lisp_Object var;
1534 /* Fsignal stores here the condition-case clause that applies,
1535 and Fcondition_case thus knows which clause to run. */
1536 Lisp_Object chosen_clause;
1537
1538 /* Used to effect the longjump out to the handler. */
1539 struct catchtag *tag;
1540
1541 /* The next enclosing handler. */
1542 struct handler *next;
1543 };
1544
1545extern struct handler *handlerlist;
1546
1547extern struct catchtag *catchlist;
1548extern struct backtrace *backtrace_list;
1549
1550extern Lisp_Object memory_signal_data;
1551
1552/* An address near the bottom of the stack.
1553 Tells GC how to save a copy of the stack. */
1554extern char *stack_bottom;
1555
1556/* Check quit-flag and quit if it is non-nil.
1557 Typing C-g does not directly cause a quit; it only sets Vquit_flag.
1558 So the program needs to do QUIT at times when it is safe to quit.
1559 Every loop that might run for a long time or might not exit
1560 ought to do QUIT at least once, at a safe place.
1561 Unless that is impossible, of course.
1562 But it is very desirable to avoid creating loops where QUIT is impossible.
1563
1564 Exception: if you set immediate_quit to nonzero,
1565 then the handler that responds to the C-g does the quit itself.
1566 This is a good thing to do around a loop that has no side effects
1567 and (in particular) cannot call arbitrary Lisp code. */
1568
1569#define QUIT \
1570 do { \
1571 if (!NILP (Vquit_flag) && NILP (Vinhibit_quit)) \
1572 { \
1573 Vquit_flag = Qnil; \
1574 Fsignal (Qquit, Qnil); \
1575 } \
1576 } while (0)
1577
1578/* Nonzero if ought to quit now. */
1579
1580#define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
1581\f
1582/* Variables used locally in the following case handling macros. */
1583extern int case_temp1;
1584extern Lisp_Object case_temp2;
1585
1586/* Current buffer's map from characters to lower-case characters. */
1587
1588#define DOWNCASE_TABLE current_buffer->downcase_table
1589
1590/* Current buffer's map from characters to upper-case characters. */
1591
1592#define UPCASE_TABLE current_buffer->upcase_table
1593
1594/* Downcase a character, or make no change if that cannot be done. */
1595
1596#define DOWNCASE(CH) \
1597 ((case_temp1 = (CH), \
1598 case_temp2 = CHAR_TABLE_REF (DOWNCASE_TABLE, case_temp1), \
1599 NATNUMP (case_temp2)) \
1600 ? XFASTINT (case_temp2) : case_temp1)
1601
1602/* 1 if CH is upper case. */
1603
1604#define UPPERCASEP(CH) (DOWNCASE (CH) != (CH))
1605
1606/* 1 if CH is neither upper nor lower case. */
1607
1608#define NOCASEP(CH) (UPCASE1 (CH) == (CH))
1609
1610/* 1 if CH is lower case. */
1611
1612#define LOWERCASEP(CH) (!UPPERCASEP (CH) && !NOCASEP(CH))
1613
1614/* Upcase a character, or make no change if that cannot be done. */
1615
1616#define UPCASE(CH) (!UPPERCASEP (CH) ? UPCASE1 (CH) : (CH))
1617
1618/* Upcase a character known to be not upper case. */
1619
1620#define UPCASE1(CH) \
1621 ((case_temp1 = (CH), \
1622 case_temp2 = CHAR_TABLE_REF (UPCASE_TABLE, case_temp1), \
1623 NATNUMP (case_temp2)) \
1624 ? XFASTINT (case_temp2) : case_temp1)
1625
1626extern Lisp_Object Vascii_downcase_table;
1627\f
1628/* Number of bytes of structure consed since last GC. */
1629
1630extern int consing_since_gc;
1631
1632/* Threshold for doing another gc. */
1633
1634extern int gc_cons_threshold;
1635
1636/* Structure for recording stack slots that need marking. */
1637
1638/* This is a chain of structures, each of which points at a Lisp_Object variable
1639 whose value should be marked in garbage collection.
1640 Normally every link of the chain is an automatic variable of a function,
1641 and its `val' points to some argument or local variable of the function.
1642 On exit to the function, the chain is set back to the value it had on entry.
1643 This way, no link remains in the chain when the stack frame containing the
1644 link disappears.
1645
1646 Every function that can call Feval must protect in this fashion all
1647 Lisp_Object variables whose contents will be used again. */
1648
1649extern struct gcpro *gcprolist;
1650
1651struct gcpro
1652{
1653 struct gcpro *next;
1654
1655 /* Address of first protected variable. */
1656 volatile Lisp_Object *var;
1657
1658 /* Number of consecutive protected variables. */
1659 int nvars;
1660
1661#ifdef DEBUG_GCPRO
1662 int level;
1663#endif
1664};
1665
1666/* Values of GC_MARK_STACK during compilation:
1667
1668 0 Use GCPRO as before
1669 1 Do the real thing, make GCPROs and UNGCPRO no-ops.
1670 2 Mark the stack, and check that everything GCPRO'd is
1671 marked.
1672 3 Mark using GCPRO's, mark stack last, and count how many
1673 dead objects are kept alive. */
1674
1675
1676#define GC_USE_GCPROS_AS_BEFORE 0
1677#define GC_MAKE_GCPROS_NOOPS 1
1678#define GC_MARK_STACK_CHECK_GCPROS 2
1679#define GC_USE_GCPROS_CHECK_ZOMBIES 3
1680
1681#ifndef GC_MARK_STACK
1682#define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
1683#endif
1684
1685#if GC_MARK_STACK == GC_MAKE_GCPROS_NOOPS
1686
1687#define GCPRO1(varname) ((void) 0)
1688#define GCPRO2(varname1, varname2)((void) 0)
1689#define GCPRO3(varname1, varname2, varname3) ((void) 0)
1690#define GCPRO4(varname1, varname2, varname3, varname4) ((void) 0)
1691#define GCPRO5(varname1, varname2, varname3, varname4, varname5) ((void) 0)
1692#define UNGCPRO ((void) 0)
1693
1694#else /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
1695
1696#ifndef DEBUG_GCPRO
1697
1698#define GCPRO1(varname) \
1699 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1700 gcprolist = &gcpro1; }
1701
1702#define GCPRO2(varname1, varname2) \
1703 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1704 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1705 gcprolist = &gcpro2; }
1706
1707#define GCPRO3(varname1, varname2, varname3) \
1708 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1709 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1710 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1711 gcprolist = &gcpro3; }
1712
1713#define GCPRO4(varname1, varname2, varname3, varname4) \
1714 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1715 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1716 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1717 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1718 gcprolist = &gcpro4; }
1719
1720#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1721 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1722 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1723 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1724 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1725 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1726 gcprolist = &gcpro5; }
1727
1728#define UNGCPRO (gcprolist = gcpro1.next)
1729
1730#else
1731
1732extern int gcpro_level;
1733
1734#define GCPRO1(varname) \
1735 {gcpro1.next = gcprolist; gcpro1.var = &varname; gcpro1.nvars = 1; \
1736 gcpro1.level = gcpro_level++; \
1737 gcprolist = &gcpro1; }
1738
1739#define GCPRO2(varname1, varname2) \
1740 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1741 gcpro1.level = gcpro_level; \
1742 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1743 gcpro2.level = gcpro_level++; \
1744 gcprolist = &gcpro2; }
1745
1746#define GCPRO3(varname1, varname2, varname3) \
1747 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1748 gcpro1.level = gcpro_level; \
1749 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1750 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1751 gcpro3.level = gcpro_level++; \
1752 gcprolist = &gcpro3; }
1753
1754#define GCPRO4(varname1, varname2, varname3, varname4) \
1755 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1756 gcpro1.level = gcpro_level; \
1757 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1758 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1759 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1760 gcpro4.level = gcpro_level++; \
1761 gcprolist = &gcpro4; }
1762
1763#define GCPRO5(varname1, varname2, varname3, varname4, varname5) \
1764 {gcpro1.next = gcprolist; gcpro1.var = &varname1; gcpro1.nvars = 1; \
1765 gcpro1.level = gcpro_level; \
1766 gcpro2.next = &gcpro1; gcpro2.var = &varname2; gcpro2.nvars = 1; \
1767 gcpro3.next = &gcpro2; gcpro3.var = &varname3; gcpro3.nvars = 1; \
1768 gcpro4.next = &gcpro3; gcpro4.var = &varname4; gcpro4.nvars = 1; \
1769 gcpro5.next = &gcpro4; gcpro5.var = &varname5; gcpro5.nvars = 1; \
1770 gcpro5.level = gcpro_level++; \
1771 gcprolist = &gcpro5; }
1772
1773#define UNGCPRO \
1774 ((--gcpro_level != gcpro1.level) \
1775 ? (abort (), 0) \
1776 : ((gcprolist = gcpro1.next), 0))
1777
1778#endif /* DEBUG_GCPRO */
1779#endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
1780
1781
1782/* Evaluate expr, UNGCPRO, and then return the value of expr. */
1783#define RETURN_UNGCPRO(expr) \
1784do \
1785 { \
1786 Lisp_Object ret_ungc_val; \
1787 ret_ungc_val = (expr); \
1788 UNGCPRO; \
1789 return ret_ungc_val; \
1790 } \
1791while (0)
1792
1793/* Call staticpro (&var) to protect static variable `var'. */
1794
1795void staticpro P_ ((Lisp_Object *));
1796\f
1797/* Declare a Lisp-callable function. The MAXARGS parameter has the same
1798 meaning as in the DEFUN macro, and is used to construct a prototype. */
1799#if (!defined (__STDC__) && !defined (PROTOTYPES)) \
1800 || defined (USE_NONANSI_DEFUN)
1801#define EXFUN(fnname, maxargs) \
1802 extern Lisp_Object fnname ()
1803#else
1804/* We can use the same trick as in the DEFUN macro to generate the
1805 appropriate prototype. */
1806#define EXFUN(fnname, maxargs) \
1807 extern Lisp_Object fnname DEFUN_ARGS_ ## maxargs
1808#endif
1809
1810/* Forward declarations for prototypes. */
1811struct window;
1812struct frame;
1813
1814/* Defined in data.c */
1815extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qsubr, Qunbound;
1816extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
1817extern Lisp_Object Qerror, Qquit, Qwrong_type_argument, Qargs_out_of_range;
1818extern Lisp_Object Qvoid_variable, Qvoid_function;
1819extern Lisp_Object Qsetting_constant, Qinvalid_read_syntax;
1820extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
1821extern Lisp_Object Qend_of_file, Qarith_error;
1822extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
1823extern Lisp_Object Qmark_inactive, Qtext_read_only;
1824
1825extern Lisp_Object Qrange_error, Qdomain_error, Qsingularity_error;
1826extern Lisp_Object Qoverflow_error, Qunderflow_error;
1827
1828extern Lisp_Object Qintegerp, Qnumberp, Qnatnump, Qwholenump;
1829extern Lisp_Object Qsymbolp, Qlistp, Qconsp;
1830extern Lisp_Object Qstringp, Qarrayp, Qsequencep, Qbufferp;
1831extern Lisp_Object Qchar_or_string_p, Qmarkerp, Qvectorp;
1832extern Lisp_Object Qinteger_or_marker_p, Qnumber_or_marker_p;
1833extern Lisp_Object Qchar_table_p, Qvector_or_char_table_p;
1834extern Lisp_Object Qboundp, Qfboundp;
1835extern Lisp_Object Qbuffer_or_string_p;
1836extern Lisp_Object Qcdr;
1837
1838extern Lisp_Object Qfloatp, Qinteger_or_floatp, Qinteger_or_float_or_marker_p;
1839
1840extern Lisp_Object Qframep;
1841
1842EXFUN (Feq, 2);
1843EXFUN (Fnull, 1);
1844EXFUN (Flistp, 1);
1845EXFUN (Fconsp, 1);
1846EXFUN (Fatom, 1);
1847EXFUN (Fnlistp, 1);
1848EXFUN (Fintegerp, 1);
1849EXFUN (Fnatnump, 1);
1850EXFUN (Fsymbolp, 1);
1851EXFUN (Fvectorp, 1);
1852EXFUN (Fstringp, 1);
1853EXFUN (Fmultibyte_string_p, 1);
1854EXFUN (Farrayp, 1);
1855EXFUN (Fsequencep, 1);
1856EXFUN (Fbufferp, 1);
1857EXFUN (Fmarkerp, 1);
1858EXFUN (Fsubrp, 1);
1859EXFUN (Fchar_or_string_p, 1);
1860EXFUN (Finteger_or_marker_p, 1);
1861EXFUN (Ffloatp, 1);
1862EXFUN (Finteger_or_floatp, 1);
1863EXFUN (Finteger_or_float_or_marker_p, 1);
1864
1865EXFUN (Fcar, 1);
1866EXFUN (Fcar_safe, 1);
1867EXFUN (Fcdr, 1);
1868EXFUN (Fcdr_safe, 1);
1869EXFUN (Fsetcar, 2);
1870EXFUN (Fsetcdr, 2);
1871EXFUN (Fboundp, 1);
1872EXFUN (Ffboundp, 1);
1873EXFUN (Fmakunbound, 1);
1874EXFUN (Ffmakunbound, 1);
1875EXFUN (Fsymbol_function, 1);
1876EXFUN (Fsymbol_plist, 1);
1877EXFUN (Fsymbol_name, 1);
1878extern Lisp_Object indirect_function P_ ((Lisp_Object));
1879EXFUN (Findirect_function, 1);
1880EXFUN (Ffset, 2);
1881EXFUN (Fsetplist, 2);
1882EXFUN (Fsymbol_value, 1);
1883extern Lisp_Object find_symbol_value P_ ((Lisp_Object));
1884EXFUN (Fset, 2);
1885EXFUN (Fdefault_value, 1);
1886EXFUN (Fset_default, 2);
1887EXFUN (Fdefault_boundp, 1);
1888EXFUN (Fmake_local_variable, 1);
1889EXFUN (Flocal_variable_p, 2);
1890EXFUN (Flocal_variable_if_set_p, 2);
1891
1892EXFUN (Faref, 2);
1893EXFUN (Faset, 3);
1894
1895EXFUN (Fstring_to_number, 2);
1896EXFUN (Fnumber_to_string, 1);
1897EXFUN (Feqlsign, 2);
1898EXFUN (Fgtr, 2);
1899EXFUN (Flss, 2);
1900EXFUN (Fgeq, 2);
1901EXFUN (Fleq, 2);
1902EXFUN (Fneq, 2);
1903EXFUN (Fzerop, 1);
1904EXFUN (Fplus, MANY);
1905EXFUN (Fminus, MANY);
1906EXFUN (Ftimes, MANY);
1907EXFUN (Fquo, MANY);
1908EXFUN (Frem, 2);
1909EXFUN (Fmax, MANY);
1910EXFUN (Fmin, MANY);
1911EXFUN (Flogand, MANY);
1912EXFUN (Flogior, MANY);
1913EXFUN (Flogxor, MANY);
1914EXFUN (Flognot, 1);
1915EXFUN (Flsh, 2);
1916EXFUN (Fash, 2);
1917
1918EXFUN (Fadd1, 1);
1919EXFUN (Fsub1, 1);
1920EXFUN (Fmake_variable_buffer_local, 1);
1921
1922extern Lisp_Object long_to_cons P_ ((unsigned long));
1923extern unsigned long cons_to_long P_ ((Lisp_Object));
1924extern void args_out_of_range P_ ((Lisp_Object, Lisp_Object));
1925extern void args_out_of_range_3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1926extern Lisp_Object wrong_type_argument P_ ((Lisp_Object, Lisp_Object));
1927extern void store_symval_forwarding P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
1928extern Lisp_Object do_symval_forwarding P_ ((Lisp_Object));
1929extern Lisp_Object set_internal P_ ((Lisp_Object, Lisp_Object, struct buffer *, int));
1930extern void syms_of_data P_ ((void));
1931extern void init_data P_ ((void));
1932extern void swap_in_global_binding P_ ((Lisp_Object));
1933
1934/* Defined in cmds.c */
1935EXFUN (Fend_of_line, 1);
1936EXFUN (Fforward_char, 1);
1937EXFUN (Fforward_line, 1);
1938extern int forward_point P_ ((int));
1939extern int internal_self_insert P_ ((int, int));
1940extern void syms_of_cmds P_ ((void));
1941extern void keys_of_cmds P_ ((void));
1942
1943/* Defined in coding.c */
1944EXFUN (Fcoding_system_p, 1);
1945EXFUN (Fcheck_coding_system, 1);
1946EXFUN (Fread_coding_system, 2);
1947EXFUN (Fread_non_nil_coding_system, 1);
1948EXFUN (Ffind_operation_coding_system, MANY);
1949EXFUN (Fencode_coding_string, 3);
1950EXFUN (Fdecode_coding_string, 3);
1951extern Lisp_Object detect_coding_system P_ ((unsigned char *, int, int, int));
1952Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object, int));
1953extern void init_coding P_ ((void));
1954extern void init_coding_once P_ ((void));
1955extern void syms_of_coding P_ ((void));
1956extern Lisp_Object code_convert_string_norecord P_ ((Lisp_Object, Lisp_Object,
1957 int));
1958
1959/* Defined in charset.c */
1960extern int nonascii_insert_offset;
1961extern Lisp_Object Vnonascii_translation_table;
1962EXFUN (Fchar_bytes, 1);
1963EXFUN (Fchar_width, 1);
1964EXFUN (Fstring, MANY);
1965extern int chars_in_text P_ ((unsigned char *, int));
1966extern int multibyte_chars_in_text P_ ((unsigned char *, int));
1967extern int unibyte_char_to_multibyte P_ ((int));
1968extern int multibyte_char_to_unibyte P_ ((int, Lisp_Object));
1969extern Lisp_Object Qcharset;
1970extern void init_charset_once P_ ((void));
1971extern void syms_of_charset P_ ((void));
1972
1973/* Defined in syntax.c */
1974EXFUN (Fforward_word, 1);
1975EXFUN (Fskip_chars_forward, 2);
1976EXFUN (Fskip_chars_backward, 2);
1977EXFUN (Fsyntax_table_p, 1);
1978EXFUN (Fsyntax_table, 0);
1979EXFUN (Fset_syntax_table, 1);
1980extern void init_syntax_once P_ ((void));
1981extern void syms_of_syntax P_ ((void));
1982
1983/* Defined in fns.c */
1984extern int use_dialog_box;
1985extern int next_almost_prime P_ ((int));
1986extern Lisp_Object larger_vector P_ ((Lisp_Object, int, Lisp_Object));
1987extern void sweep_weak_hash_tables P_ ((void));
1988extern Lisp_Object Qstring_lessp;
1989EXFUN (Foptimize_char_table, 1);
1990extern Lisp_Object Vfeatures;
1991extern Lisp_Object QCtest, QCweakness, Qequal;
1992unsigned sxhash P_ ((Lisp_Object, int));
1993Lisp_Object make_hash_table P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
1994 Lisp_Object, Lisp_Object, Lisp_Object,
1995 Lisp_Object));
1996Lisp_Object copy_hash_table P_ ((struct Lisp_Hash_Table *));
1997int hash_lookup P_ ((struct Lisp_Hash_Table *, Lisp_Object, unsigned *));
1998int hash_put P_ ((struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
1999 unsigned));
2000void hash_remove P_ ((struct Lisp_Hash_Table *, Lisp_Object));
2001void hash_clear P_ ((struct Lisp_Hash_Table *));
2002void remove_hash_entry P_ ((struct Lisp_Hash_Table *, int));
2003extern void init_fns P_ ((void));
2004EXFUN (Fsxhash, 1);
2005EXFUN (Fmake_hash_table, MANY);
2006EXFUN (Fcopy_hash_table, 1);
2007EXFUN (Fhash_table_count, 1);
2008EXFUN (Fhash_table_rehash_size, 1);
2009EXFUN (Fhash_table_rehash_threshold, 1);
2010EXFUN (Fhash_table_size, 1);
2011EXFUN (Fhash_table_test, 1);
2012EXFUN (Fhash_table_weak, 1);
2013EXFUN (Fhash_table_p, 1);
2014EXFUN (Fclrhash, 1);
2015EXFUN (Fgethash, 3);
2016EXFUN (Fputhash, 3);
2017EXFUN (Fremhash, 2);
2018EXFUN (Fmaphash, 2);
2019EXFUN (Fdefine_hash_table_test, 3);
2020
2021EXFUN (Fidentity, 1);
2022EXFUN (Frandom, 1);
2023EXFUN (Flength, 1);
2024EXFUN (Fsafe_length, 1);
2025EXFUN (Fappend, MANY);
2026EXFUN (Fconcat, MANY);
2027EXFUN (Fvconcat, MANY);
2028EXFUN (Fcopy_sequence, 1);
2029EXFUN (Fstring_make_multibyte, 1);
2030EXFUN (Fstring_make_unibyte, 1);
2031EXFUN (Fstring_as_multibyte, 1);
2032EXFUN (Fstring_as_unibyte, 1);
2033EXFUN (Fsubstring, 3);
2034extern Lisp_Object substring_both P_ ((Lisp_Object, int, int, int, int));
2035EXFUN (Fnth, 2);
2036EXFUN (Fnthcdr, 2);
2037EXFUN (Fmemq, 2);
2038EXFUN (Fassq, 2);
2039EXFUN (Fassoc, 2);
2040EXFUN (Felt, 2);
2041EXFUN (Fmember, 2);
2042EXFUN (Frassq, 2);
2043EXFUN (Fdelq, 2);
2044EXFUN (Fsort, 2);
2045EXFUN (Freverse, 1);
2046EXFUN (Fnreverse, 1);
2047EXFUN (Fget, 2);
2048EXFUN (Fput, 3);
2049EXFUN (Fequal, 2);
2050EXFUN (Ffillarray, 2);
2051EXFUN (Fnconc, MANY);
2052EXFUN (Fmapcar, 2);
2053EXFUN (Fmapconcat, 3);
2054EXFUN (Fy_or_n_p, 1);
2055extern Lisp_Object do_yes_or_no_p P_ ((Lisp_Object));
2056EXFUN (Ffeaturep, 1);
2057EXFUN (Frequire, 3);
2058EXFUN (Fprovide, 1);
2059extern Lisp_Object concat2 P_ ((Lisp_Object, Lisp_Object));
2060extern Lisp_Object concat3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2061extern Lisp_Object nconc2 P_ ((Lisp_Object, Lisp_Object));
2062extern Lisp_Object assq_no_quit P_ ((Lisp_Object, Lisp_Object));
2063extern void clear_string_char_byte_cache P_ ((void));
2064extern int string_char_to_byte P_ ((Lisp_Object, int));
2065extern int string_byte_to_char P_ ((Lisp_Object, int));
2066extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
2067extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
2068EXFUN (Fcopy_alist, 1);
2069EXFUN (Fplist_get, 2);
2070EXFUN (Fplist_put, 3);
2071EXFUN (Fset_char_table_parent, 2);
2072EXFUN (Fchar_table_extra_slot, 2);
2073EXFUN (Fset_char_table_extra_slot, 3);
2074EXFUN (Frassoc, 2);
2075EXFUN (Fstring_equal, 2);
2076EXFUN (Fcompare_strings, 7);
2077EXFUN (Fstring_lessp, 2);
2078extern int char_table_translate P_ ((Lisp_Object, int));
2079extern void map_char_table P_ ((void (*) (Lisp_Object, Lisp_Object, Lisp_Object),
2080 Lisp_Object, Lisp_Object, Lisp_Object, int,
2081 Lisp_Object *));
2082extern Lisp_Object char_table_ref_and_index P_ ((Lisp_Object, int, int *));
2083extern void syms_of_fns P_ ((void));
2084
2085/* Defined in floatfns.c */
2086extern double extract_float P_ ((Lisp_Object));
2087EXFUN (Ffloat, 1);
2088EXFUN (Ftruncate, 2);
2089extern void init_floatfns P_ ((void));
2090extern void syms_of_floatfns P_ ((void));
2091
2092/* Defined in insdel.c */
2093extern void move_gap P_ ((int));
2094extern void move_gap_both P_ ((int, int));
2095extern void make_gap P_ ((int));
2096extern int copy_text P_ ((unsigned char *, unsigned char *, int, int, int));
2097extern int count_size_as_multibyte P_ ((unsigned char *, int));
2098extern int count_combining_before P_ ((unsigned char *, int, int, int));
2099extern int count_combining_after P_ ((unsigned char *, int, int, int));
2100extern void insert P_ ((unsigned char *, int));
2101extern void insert_and_inherit P_ ((unsigned char *, int));
2102extern void insert_1 P_ ((unsigned char *, int, int, int, int));
2103extern void insert_1_both P_ ((unsigned char *, int, int, int, int, int));
2104extern void insert_from_string P_ ((Lisp_Object, int, int, int, int, int));
2105extern void insert_from_buffer P_ ((struct buffer *, int, int, int));
2106extern void insert_char P_ ((int));
2107extern void insert_string P_ ((char *));
2108extern void insert_before_markers P_ ((unsigned char *, int));
2109extern void insert_before_markers_and_inherit P_ ((unsigned char *, int));
2110extern void insert_from_string_before_markers P_ ((Lisp_Object, int, int, int, int, int));
2111extern void del_range P_ ((int, int));
2112extern Lisp_Object del_range_1 P_ ((int, int, int, int));
2113extern void del_range_byte P_ ((int, int, int));
2114extern void del_range_both P_ ((int, int, int, int, int));
2115extern Lisp_Object del_range_2 P_ ((int, int, int, int, int));
2116extern void modify_region P_ ((struct buffer *, int, int));
2117extern void prepare_to_modify_buffer P_ ((int, int, int *));
2118extern void signal_before_change P_ ((int, int, int *));
2119extern void signal_after_change P_ ((int, int, int));
2120extern void adjust_after_replace P_ ((int, int, Lisp_Object, int, int));
2121extern void adjust_after_insert P_ ((int, int, int, int, int));
2122extern void replace_range P_ ((int, int, Lisp_Object, int, int, int));
2123extern void syms_of_insdel P_ ((void));
2124
2125/* Defined in dispnew.c */
2126extern Lisp_Object selected_frame;
2127EXFUN (Fding, 1);
2128EXFUN (Fredraw_frame, 1);
2129EXFUN (Fredraw_display, 0);
2130EXFUN (Fsleep_for, 2);
2131EXFUN (Fsit_for, 3);
2132extern Lisp_Object sit_for P_ ((int, int, int, int, int));
2133extern void init_display P_ ((void));
2134extern void syms_of_display P_ ((void));
2135extern void safe_bcopy P_ ((char *, char *, int));
2136
2137/* Defined in xdisp.c */
2138extern Lisp_Object Qinhibit_point_motion_hooks;
2139extern Lisp_Object Qinhibit_redisplay, Qdisplay;
2140extern Lisp_Object Qmessage_truncate_lines;
2141extern Lisp_Object Vmessage_log_max;
2142extern int message_enable_multibyte;
2143extern Lisp_Object echo_area_buffer[2];
2144extern void check_message_stack P_ ((void));
2145extern void setup_echo_area_for_printing P_ ((int));
2146extern int push_message P_ ((void));
2147extern Lisp_Object push_message_unwind P_ ((Lisp_Object));
2148extern void pop_message P_ ((void));
2149extern void restore_message P_ ((void));
2150extern Lisp_Object current_message P_ ((void));
2151extern void set_message P_ ((char *s, Lisp_Object, int, int));
2152extern void clear_message P_ ((int, int));
2153extern void message P_ ((/* char *, ... */));
2154extern void message_nolog P_ ((/* char *, ... */));
2155extern void message1 P_ ((char *));
2156extern void message1_nolog P_ ((char *));
2157extern void message2 P_ ((char *, int, int));
2158extern void message2_nolog P_ ((char *, int, int));
2159extern void message3 P_ ((Lisp_Object, int, int));
2160extern void message3_nolog P_ ((Lisp_Object, int, int));
2161extern void message_dolog P_ ((char *, int, int, int));
2162extern void message_with_string P_ ((char *, Lisp_Object, int));
2163extern void message_log_maybe_newline P_ ((void));
2164extern void update_echo_area P_ ((void));
2165extern void truncate_echo_area P_ ((int));
2166extern void redisplay P_ ((void));
2167extern int check_point_in_composition
2168 P_ ((struct buffer *, int, struct buffer *, int));
2169extern void redisplay_preserve_echo_area P_ ((void));
2170extern void mark_window_display_accurate P_ ((Lisp_Object, int));
2171extern int invisible_p P_ ((Lisp_Object, Lisp_Object));
2172extern void prepare_menu_bars P_ ((void));
2173extern void syms_of_xdisp P_ ((void));
2174extern void init_xdisp P_ ((void));
2175extern Lisp_Object safe_eval P_ ((Lisp_Object));
2176extern int pos_visible_p P_ ((struct window *, int, int *, int));
2177
2178/* Defined in vm-limit.c. */
2179extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
2180
2181/* Defined in alloc.c */
2182extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
2183extern void uninterrupt_malloc P_ ((void));
2184extern void malloc_warning P_ ((char *));
2185extern void memory_full P_ ((void));
2186extern void buffer_memory_full P_ ((void));
2187extern int survives_gc_p P_ ((Lisp_Object));
2188extern void mark_object P_ ((Lisp_Object *));
2189extern Lisp_Object Vpurify_flag;
2190EXFUN (Fcons, 2);
2191EXFUN (list2, 2);
2192EXFUN (list3, 3);
2193EXFUN (list4, 4);
2194EXFUN (list5, 5);
2195EXFUN (Flist, MANY);
2196EXFUN (Fmake_list, 2);
2197extern Lisp_Object allocate_misc P_ ((void));
2198EXFUN (Fmake_vector, 2);
2199EXFUN (Fvector, MANY);
2200EXFUN (Fmake_symbol, 1);
2201EXFUN (Fmake_marker, 0);
2202EXFUN (Fmake_string, 2);
2203extern Lisp_Object build_string P_ ((char *));
2204extern Lisp_Object make_string P_ ((char *, int));
2205extern Lisp_Object make_unibyte_string P_ ((char *, int));
2206extern Lisp_Object make_multibyte_string P_ ((char *, int, int));
2207extern Lisp_Object make_event_array P_ ((int, Lisp_Object *));
2208extern Lisp_Object make_uninit_string P_ ((int));
2209extern Lisp_Object make_uninit_multibyte_string P_ ((int, int));
2210extern Lisp_Object make_string_from_bytes P_ ((char *, int, int));
2211extern Lisp_Object make_specified_string P_ ((char *, int, int, int));
2212EXFUN (Fpurecopy, 1);
2213extern Lisp_Object make_pure_string P_ ((char *, int, int, int));
2214extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
2215extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
2216EXFUN (Fgarbage_collect, 0);
2217EXFUN (Fmake_byte_code, MANY);
2218EXFUN (Fmake_bool_vector, 2);
2219EXFUN (Fmake_char_table, 2);
2220extern Lisp_Object make_sub_char_table P_ ((Lisp_Object));
2221extern Lisp_Object Qchar_table_extra_slots;
2222extern struct Lisp_Vector *allocate_vectorlike P_ ((EMACS_INT));
2223extern int gc_in_progress;
2224extern Lisp_Object make_float P_ ((double));
2225extern void display_malloc_warning P_ ((void));
2226extern int inhibit_garbage_collection P_ ((void));
2227extern void free_marker P_ ((Lisp_Object));
2228extern void free_cons P_ ((struct Lisp_Cons *));
2229extern void init_alloc_once P_ ((void));
2230extern void init_alloc P_ ((void));
2231extern void syms_of_alloc P_ ((void));
2232extern struct buffer * allocate_buffer P_ ((void));
2233
2234/* Defined in print.c */
2235extern Lisp_Object Vprin1_to_string_buffer;
2236extern void debug_print P_ ((Lisp_Object));
2237EXFUN (Fprin1, 2);
2238EXFUN (Fprin1_to_string, 2);
2239EXFUN (Fprinc, 2);
2240EXFUN (Fterpri, 1);
2241EXFUN (Fprint, 2);
2242EXFUN (Ferror_message_string, 1);
2243extern Lisp_Object Vstandard_output, Qstandard_output;
2244extern Lisp_Object Qexternal_debugging_output;
2245extern void temp_output_buffer_setup P_ ((char *));
2246extern int print_level, print_escape_newlines;
2247extern Lisp_Object Qprint_escape_newlines;
2248extern void write_string P_ ((char *, int));
2249extern void write_string_1 P_ ((char *, int, Lisp_Object));
2250extern void print_error_message P_ ((Lisp_Object, Lisp_Object));
2251extern Lisp_Object internal_with_output_to_temp_buffer
2252 P_ ((char *, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2253extern void float_to_string P_ ((unsigned char *, double));
2254extern void syms_of_print P_ ((void));
2255
2256/* Defined in doprnt.c */
2257extern int doprnt P_ ((char *, int, char *, char *, int, char **));
2258extern int doprnt_lisp P_ ((char *, int, char *, char *, int, char **));
2259
2260/* Defined in lread.c */
2261extern Lisp_Object Qvariable_documentation, Qstandard_input;
2262extern Lisp_Object Vobarray, initial_obarray, Vstandard_input;
2263EXFUN (Fread, 1);
2264EXFUN (Fread_from_string, 3);
2265EXFUN (Fintern, 2);
2266EXFUN (Fintern_soft, 2);
2267EXFUN (Fload, 5);
2268EXFUN (Fget_file_char, 0);
2269EXFUN (Fread_char, 2);
2270EXFUN (Fread_event, 2);
2271extern Lisp_Object read_filtered_event P_ ((int, int, int, int));
2272EXFUN (Feval_region, 4);
2273extern Lisp_Object intern P_ ((char *));
2274extern Lisp_Object make_symbol P_ ((char *));
2275extern Lisp_Object oblookup P_ ((Lisp_Object, char *, int, int));
2276#define LOADHIST_ATTACH(x) \
2277 if (initialized) Vcurrent_load_list = Fcons (x, Vcurrent_load_list)
2278extern Lisp_Object Vcurrent_load_list;
2279extern Lisp_Object Vload_history;
2280extern int openp P_ ((Lisp_Object, Lisp_Object, char *, Lisp_Object *, int));
2281extern int isfloat_string P_ ((char *));
2282extern void map_obarray P_ ((Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
2283 Lisp_Object));
2284extern void dir_warning P_ ((char *, Lisp_Object));
2285extern void close_load_descs P_ ((void));
2286extern void init_obarray P_ ((void));
2287extern void init_lread P_ ((void));
2288extern void syms_of_lread P_ ((void));
2289
2290/* Defined in eval.c */
2291extern Lisp_Object Qautoload, Qexit, Qinteractive, Qcommandp, Qdefun, Qmacro;
2292extern Lisp_Object Vinhibit_quit, Qinhibit_quit, Vquit_flag;
2293extern Lisp_Object Vmocklisp_arguments, Qmocklisp, Qmocklisp_arguments;
2294extern Lisp_Object Vautoload_queue;
2295extern Lisp_Object Vdebug_on_error;
2296extern Lisp_Object Vsignaling_function;
2297extern int handling_signal;
2298
2299/* To run a normal hook, use the appropriate function from the list below.
2300 The calling convention:
2301
2302 if (!NILP (Vrun_hooks))
2303 call1 (Vrun_hooks, Qmy_funny_hook);
2304
2305 should no longer be used. */
2306extern Lisp_Object Vrun_hooks;
2307EXFUN (Frun_hooks, MANY);
2308EXFUN (Frun_hook_with_args, MANY);
2309EXFUN (Frun_hook_with_args_until_success, MANY);
2310EXFUN (Frun_hook_with_args_until_failure, MANY);
2311extern Lisp_Object run_hook_list_with_args P_ ((Lisp_Object, int, Lisp_Object *));
2312extern void run_hook_with_args_2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2313EXFUN (Fand, UNEVALLED);
2314EXFUN (For, UNEVALLED);
2315EXFUN (Fif, UNEVALLED);
2316EXFUN (Fprogn, UNEVALLED);
2317EXFUN (Fprog1, UNEVALLED);
2318EXFUN (Fprog2, UNEVALLED);
2319EXFUN (Fsetq, UNEVALLED);
2320EXFUN (Fquote, UNEVALLED);
2321EXFUN (Fuser_variable_p, 1);
2322EXFUN (Finteractive_p, 0);
2323EXFUN (Fdefun, UNEVALLED);
2324EXFUN (Flet, UNEVALLED);
2325EXFUN (FletX, UNEVALLED);
2326EXFUN (Fwhile, UNEVALLED);
2327EXFUN (Fcatch, UNEVALLED);
2328EXFUN (Fthrow, 2) NO_RETURN;
2329EXFUN (Funwind_protect, UNEVALLED);
2330EXFUN (Fcondition_case, UNEVALLED);
2331EXFUN (Fsignal, 2);
2332EXFUN (Fautoload, 5);
2333EXFUN (Fcommandp, 1);
2334EXFUN (Feval, 1);
2335EXFUN (Fapply, MANY);
2336EXFUN (Ffuncall, MANY);
2337EXFUN (Fbacktrace, 0);
2338extern Lisp_Object apply1 P_ ((Lisp_Object, Lisp_Object));
2339extern Lisp_Object call0 P_ ((Lisp_Object));
2340extern Lisp_Object call1 P_ ((Lisp_Object, Lisp_Object));
2341extern Lisp_Object call2 P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2342extern Lisp_Object call3 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2343extern Lisp_Object call4 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2344extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2345extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
2346EXFUN (Fdo_auto_save, 2);
2347extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
2348extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
2349extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2350extern Lisp_Object internal_condition_case_1 P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2351extern Lisp_Object internal_condition_case_2 P_ ((Lisp_Object (*) (int, Lisp_Object *), int, Lisp_Object *, Lisp_Object, Lisp_Object (*) (Lisp_Object)));
2352extern void specbind P_ ((Lisp_Object, Lisp_Object));
2353extern void record_unwind_protect P_ ((Lisp_Object (*) (Lisp_Object), Lisp_Object));
2354extern Lisp_Object unbind_to P_ ((int, Lisp_Object));
2355extern void error P_ ((/* char *, ... */)) NO_RETURN;
2356extern void do_autoload P_ ((Lisp_Object, Lisp_Object));
2357extern Lisp_Object un_autoload P_ ((Lisp_Object));
2358EXFUN (Ffetch_bytecode, 1);
2359extern void init_eval_once P_ ((void));
2360extern Lisp_Object safe_call P_ ((int, Lisp_Object *));
2361extern Lisp_Object safe_call1 P_ ((Lisp_Object, Lisp_Object));
2362extern void init_eval P_ ((void));
2363extern void syms_of_eval P_ ((void));
2364
2365/* Defined in editfns.c */
2366EXFUN (Fcurrent_message, 0);
2367EXFUN (Fgoto_char, 1);
2368EXFUN (Fpoint_min_marker, 0);
2369EXFUN (Fpoint_max_marker, 0);
2370EXFUN (Fpoint_min, 0);
2371EXFUN (Fpoint_max, 0);
2372EXFUN (Fpoint, 0);
2373EXFUN (Fpoint_marker, 0);
2374EXFUN (Fmark_marker, 0);
2375EXFUN (Fline_beginning_position, 1);
2376EXFUN (Fline_end_position, 1);
2377EXFUN (Ffollowing_char, 0);
2378EXFUN (Fprevious_char, 0);
2379EXFUN (Fchar_after, 1);
2380EXFUN (Finsert, MANY);
2381EXFUN (Finsert_and_inherit, MANY);
2382EXFUN (Finsert_before_markers, MANY);
2383EXFUN (Finsert_buffer_substring, 3);
2384EXFUN (Finsert_char, 3);
2385extern void insert1 P_ ((Lisp_Object));
2386EXFUN (Feolp, 0);
2387EXFUN (Feobp, 0);
2388EXFUN (Fbolp, 0);
2389EXFUN (Fbobp, 0);
2390EXFUN (Fformat, MANY);
2391EXFUN (Fmessage, MANY);
2392extern Lisp_Object format1 P_ ((/* char *, ... */));
2393extern Lisp_Object make_buffer_string P_ ((int, int, int));
2394EXFUN (Fbuffer_substring, 2);
2395EXFUN (Fbuffer_string, 0);
2396extern Lisp_Object save_excursion_save P_ ((void));
2397extern Lisp_Object save_restriction_save P_ ((void));
2398extern Lisp_Object save_excursion_restore P_ ((Lisp_Object));
2399extern Lisp_Object save_restriction_restore P_ ((Lisp_Object));
2400EXFUN (Fchar_to_string, 1);
2401EXFUN (Fdelete_region, 2);
2402EXFUN (Fnarrow_to_region, 2);
2403EXFUN (Fwiden, 0);
2404EXFUN (Fuser_login_name, 1);
2405EXFUN (Fsystem_name, 0);
2406EXFUN (Fcurrent_time, 0);
2407extern int clip_to_bounds P_ ((int, int, int));
2408extern Lisp_Object make_buffer_string P_ ((int, int, int));
2409extern Lisp_Object make_buffer_string_both P_ ((int, int, int, int, int));
2410extern void init_editfns P_ ((void));
2411extern void syms_of_editfns P_ ((void));
2412EXFUN (Fcurrent_message, 0);
2413extern Lisp_Object Vinhibit_field_text_motion;
2414EXFUN (Fconstrain_to_field, 5);
2415EXFUN (Ffield_string, 1);
2416EXFUN (Fdelete_field, 1);
2417EXFUN (Ffield_beginning, 2);
2418EXFUN (Ffield_string_no_properties, 1);
2419extern void set_time_zone_rule P_ ((char *));
2420
2421/* defined in buffer.c */
2422extern void nsberror P_ ((Lisp_Object));
2423extern char *no_switch_window P_ ((Lisp_Object window));
2424EXFUN (Fset_buffer_multibyte, 1);
2425EXFUN (Foverlay_start, 1);
2426EXFUN (Foverlay_end, 1);
2427extern void adjust_overlays_for_insert P_ ((int, int));
2428extern void adjust_overlays_for_delete P_ ((int, int));
2429extern void fix_overlays_in_range P_ ((int, int));
2430extern void report_overlay_modification P_ ((Lisp_Object, Lisp_Object, int,
2431 Lisp_Object, Lisp_Object, Lisp_Object));
2432extern int overlay_touches_p P_ ((int));
2433extern Lisp_Object Vbuffer_alist, Vinhibit_read_only;
2434EXFUN (Fget_buffer, 1);
2435EXFUN (Fget_buffer_create, 1);
2436EXFUN (Fset_buffer, 1);
2437EXFUN (set_buffer_if_live, 1);
2438EXFUN (Fbarf_if_buffer_read_only, 0);
2439EXFUN (Fcurrent_buffer, 0);
2440EXFUN (Fswitch_to_buffer, 2);
2441EXFUN (Fpop_to_buffer, 3);
2442EXFUN (Fother_buffer, 3);
2443EXFUN (Foverlay_get, 2);
2444EXFUN (Fbuffer_modified_p, 1);
2445EXFUN (Fset_buffer_modified_p, 1);
2446EXFUN (Fkill_buffer, 1);
2447EXFUN (Fkill_all_local_variables, 0);
2448EXFUN (Fbuffer_disable_undo, 1);
2449EXFUN (Fbuffer_enable_undo, 1);
2450EXFUN (Ferase_buffer, 0);
2451extern Lisp_Object Qoverlayp;
2452extern Lisp_Object get_truename_buffer P_ ((Lisp_Object));
2453extern struct buffer *all_buffers;
2454EXFUN (Fprevious_overlay_change, 1);
2455EXFUN (Fbuffer_file_name, 1);
2456extern void init_buffer_once P_ ((void));
2457extern void init_buffer P_ ((void));
2458extern void syms_of_buffer P_ ((void));
2459extern void keys_of_buffer P_ ((void));
2460
2461/* defined in marker.c */
2462
2463EXFUN (Fmarker_position, 1);
2464EXFUN (Fmarker_buffer, 1);
2465EXFUN (Fcopy_marker, 2);
2466EXFUN (Fset_marker, 3);
2467extern int marker_position P_ ((Lisp_Object));
2468extern int marker_byte_position P_ ((Lisp_Object));
2469extern void clear_charpos_cache P_ ((struct buffer *));
2470extern int charpos_to_bytepos P_ ((int));
2471extern int buf_charpos_to_bytepos P_ ((struct buffer *, int));
2472extern int buf_bytepos_to_charpos P_ ((struct buffer *, int));
2473extern void unchain_marker P_ ((Lisp_Object));
2474extern Lisp_Object set_marker_restricted P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
2475extern Lisp_Object set_marker_both P_ ((Lisp_Object, Lisp_Object, int, int));
2476extern Lisp_Object set_marker_restricted_both P_ ((Lisp_Object, Lisp_Object,
2477 int, int));
2478extern void syms_of_marker P_ ((void));
2479
2480/* Defined in fileio.c */
2481
2482extern Lisp_Object Qfile_error;
2483EXFUN (Ffind_file_name_handler, 2);
2484EXFUN (Ffile_name_as_directory, 1);
2485EXFUN (Fmake_temp_name, 1);
2486EXFUN (Fexpand_file_name, 2);
2487EXFUN (Ffile_name_nondirectory, 1);
2488EXFUN (Fsubstitute_in_file_name, 1);
2489EXFUN (Ffile_symlink_p, 1);
2490EXFUN (Fverify_visited_file_modtime, 1);
2491EXFUN (Ffile_exists_p, 1);
2492EXFUN (Ffile_name_absolute_p, 1);
2493EXFUN (Fdirectory_file_name, 1);
2494EXFUN (Ffile_name_directory, 1);
2495extern Lisp_Object expand_and_dir_to_file P_ ((Lisp_Object, Lisp_Object));
2496EXFUN (Ffile_accessible_directory_p, 1);
2497EXFUN (Funhandled_file_name_directory, 1);
2498EXFUN (Ffile_directory_p, 1);
2499EXFUN (Fwrite_region, 7);
2500EXFUN (Ffile_readable_p, 1);
2501EXFUN (Ffile_executable_p, 1);
2502EXFUN (Fread_file_name, 5);
2503extern Lisp_Object close_file_unwind P_ ((Lisp_Object));
2504extern void report_file_error P_ ((char *, Lisp_Object));
2505extern int internal_delete_file P_ ((Lisp_Object));
2506extern void syms_of_fileio P_ ((void));
2507EXFUN (Fmake_temp_name, 1);
2508extern void init_fileio_once P_ ((void));
2509extern Lisp_Object make_temp_name P_ ((Lisp_Object, int));
2510
2511/* Defined in abbrev.c */
2512
2513extern Lisp_Object Vfundamental_mode_abbrev_table;
2514extern void syms_of_abbrev P_ ((void));
2515
2516/* defined in search.c */
2517extern void shrink_regexp_cache P_ ((void));
2518EXFUN (Fstring_match, 3);
2519extern void restore_match_data P_ ((void));
2520EXFUN (Fmatch_data, 2);
2521EXFUN (Fset_match_data, 1);
2522EXFUN (Fmatch_beginning, 1);
2523EXFUN (Fmatch_end, 1);
2524EXFUN (Flooking_at, 1);
2525extern int fast_string_match P_ ((Lisp_Object, Lisp_Object));
2526extern int fast_c_string_match_ignore_case P_ ((Lisp_Object, char *));
2527extern int scan_buffer P_ ((int, int, int, int, int *, int));
2528extern int scan_newline P_ ((int, int, int, int, int, int));
2529extern int find_next_newline P_ ((int, int));
2530extern int find_next_newline_no_quit P_ ((int, int));
2531extern int find_before_next_newline P_ ((int, int, int));
2532extern void syms_of_search P_ ((void));
2533
2534/* defined in minibuf.c */
2535
2536extern Lisp_Object last_minibuf_string;
2537extern void choose_minibuf_frame P_ ((void));
2538extern int scmp P_ ((unsigned char *, unsigned char *, int));
2539EXFUN (Fcompleting_read, 8);
2540EXFUN (Fread_from_minibuffer, 7);
2541EXFUN (Fread_variable, 2);
2542EXFUN (Fread_buffer, 3);
2543EXFUN (Fread_minibuffer, 2);
2544EXFUN (Feval_minibuffer, 2);
2545EXFUN (Fread_string, 5);
2546EXFUN (Fread_no_blanks_input, 3);
2547extern Lisp_Object get_minibuffer P_ ((int));
2548extern void temp_echo_area_glyphs P_ ((char *));
2549extern void init_minibuf_once P_ ((void));
2550extern void syms_of_minibuf P_ ((void));
2551extern void keys_of_minibuf P_ ((void));
2552
2553/* Defined in callint.c */
2554
2555extern Lisp_Object Qminus, Qplus, Vcurrent_prefix_arg;
2556extern Lisp_Object Vcommand_history;
2557extern Lisp_Object Qcall_interactively, Qmouse_leave_buffer_hook;
2558EXFUN (Fcall_interactively, 3);
2559EXFUN (Fprefix_numeric_value, 1);
2560extern void syms_of_callint P_ ((void));
2561
2562/* defined in casefiddle.c */
2563
2564EXFUN (Fdowncase, 1);
2565EXFUN (Fupcase, 1);
2566EXFUN (Fcapitalize, 1);
2567EXFUN (Fupcase_region, 2);
2568EXFUN (Fupcase_initials, 1);
2569EXFUN (Fupcase_initials_region, 2);
2570extern void syms_of_casefiddle P_ ((void));
2571extern void keys_of_casefiddle P_ ((void));
2572
2573/* defined in casetab.c */
2574
2575EXFUN (Fset_case_table, 1);
2576EXFUN (Fset_standard_case_table, 1);
2577extern void init_casetab_once P_ ((void));
2578extern void syms_of_casetab P_ ((void));
2579
2580/* defined in keyboard.c */
2581
2582extern Lisp_Object Qdisabled, QCfilter;
2583extern Lisp_Object Vtty_erase_char, Vhelp_form, Vtop_level;
2584extern int input_pending;
2585EXFUN (Fdiscard_input, 0);
2586EXFUN (Frecursive_edit, 0);
2587EXFUN (Fcommand_execute, 4);
2588EXFUN (Finput_pending_p, 0);
2589extern Lisp_Object menu_bar_items P_ ((Lisp_Object));
2590extern Lisp_Object tool_bar_items P_ ((Lisp_Object, int *));
2591extern Lisp_Object Qvertical_scroll_bar;
2592extern void discard_mouse_events P_ ((void));
2593EXFUN (Fevent_convert_list, 1);
2594EXFUN (Fread_key_sequence, 5);
2595EXFUN (Fset_input_mode, 4);
2596extern int detect_input_pending P_ ((void));
2597extern int detect_input_pending_run_timers P_ ((int));
2598extern void safe_run_hooks P_ ((Lisp_Object));
2599extern void cmd_error_internal P_ ((Lisp_Object, char *));
2600extern Lisp_Object command_loop_1 P_ ((void));
2601extern Lisp_Object recursive_edit_1 P_ ((void));
2602extern void record_auto_save P_ ((void));
2603extern void init_keyboard P_ ((void));
2604extern void syms_of_keyboard P_ ((void));
2605extern void keys_of_keyboard P_ ((void));
2606extern char *push_key_description P_ ((unsigned int, char *, int));
2607
2608/* defined in keymap.c */
2609
2610#define KEYMAPP(m) (!NILP (get_keymap (m, 0, 0)))
2611extern Lisp_Object Qkeymap, Qmenu_bar;
2612extern Lisp_Object current_global_map;
2613EXFUN (Fmake_sparse_keymap, 1);
2614EXFUN (Fcopy_keymap, 1);
2615EXFUN (Fdefine_key, 3);
2616EXFUN (Flookup_key, 3);
2617EXFUN (Fkey_binding, 2);
2618EXFUN (Fkey_description, 1);
2619EXFUN (Fsingle_key_description, 2);
2620EXFUN (Fwhere_is_internal, 4);
2621extern Lisp_Object access_keymap P_ ((Lisp_Object, Lisp_Object, int, int, int));
2622extern Lisp_Object get_keyelt P_ ((Lisp_Object, int));
2623extern Lisp_Object get_keymap P_ ((Lisp_Object, int, int));
2624extern void describe_vector P_ ((Lisp_Object, Lisp_Object,
2625 void (*) (Lisp_Object), int,
2626 Lisp_Object, Lisp_Object, int *, int));
2627extern void describe_map_tree P_ ((Lisp_Object, int, Lisp_Object, Lisp_Object,
2628 char *, int, int, int));
2629extern int current_minor_maps P_ ((Lisp_Object **, Lisp_Object **));
2630extern void initial_define_key P_ ((Lisp_Object, int, char *));
2631extern void initial_define_lispy_key P_ ((Lisp_Object, char *, char *));
2632extern void syms_of_keymap P_ ((void));
2633extern void keys_of_keymap P_ ((void));
2634
2635/* defined in indent.c */
2636EXFUN (Fvertical_motion, 2);
2637EXFUN (Findent_to, 2);
2638EXFUN (Fcurrent_column, 0);
2639EXFUN (Fmove_to_column, 2);
2640extern int current_column P_ ((void));
2641extern void invalidate_current_column P_ ((void));
2642extern int indented_beyond_p P_ ((int, int, int));
2643extern void syms_of_indent P_ ((void));
2644
2645/* defined in window.c */
2646extern Lisp_Object Qwindowp, Qwindow_live_p;
2647EXFUN (Fwindow_end, 2);
2648EXFUN (Fselected_window, 0);
2649EXFUN (Fnext_window, 3);
2650EXFUN (Fdelete_window, 1);
2651EXFUN (Fselect_window, 1);
2652EXFUN (Fset_window_buffer, 2);
2653EXFUN (Fget_buffer_window, 2);
2654EXFUN (Fsave_window_excursion, UNEVALLED);
2655EXFUN (Fsplit_window, 3);
2656EXFUN (Fset_window_configuration, 1);
2657EXFUN (Fcurrent_window_configuration, 1);
2658extern int compare_window_configurations P_ ((Lisp_Object, Lisp_Object, int));
2659EXFUN (Fcoordinates_in_window_p, 2);
2660EXFUN (Fwindow_at, 3);
2661EXFUN (Fpos_visible_in_window_p, 3);
2662extern void mark_window_cursors_off P_ ((struct window *));
2663extern int window_internal_height P_ ((struct window *));
2664extern int window_internal_width P_ ((struct window *));
2665EXFUN (Frecenter, 1);
2666EXFUN (Fscroll_other_window, 1);
2667EXFUN (Fset_window_start, 3);
2668extern void temp_output_buffer_show P_ ((Lisp_Object));
2669extern void replace_buffer_in_all_windows P_ ((Lisp_Object));
2670extern void init_window_once P_ ((void));
2671extern void syms_of_window P_ ((void));
2672extern void keys_of_window P_ ((void));
2673
2674/* defined in frame.c */
2675extern Lisp_Object Qvisible;
2676extern void store_frame_param P_ ((struct frame *, Lisp_Object, Lisp_Object));
2677extern void store_in_alist P_ ((Lisp_Object *, Lisp_Object, Lisp_Object));
2678extern Lisp_Object do_switch_frame P_ ((Lisp_Object, Lisp_Object, int));
2679extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
2680extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
2681EXFUN (Fframep, 1);
2682EXFUN (Fselect_frame, 2);
2683EXFUN (Fselected_frame, 0);
2684EXFUN (Fwindow_frame, 1);
2685EXFUN (Fframe_root_window, 1);
2686EXFUN (Fframe_first_window, 1);
2687EXFUN (Fframe_selected_window, 1);
2688EXFUN (Fframe_list, 0);
2689EXFUN (Fnext_frame, 2);
2690EXFUN (Fdelete_frame, 2);
2691EXFUN (Fset_mouse_position, 3);
2692EXFUN (Fmake_frame_visible, 1);
2693EXFUN (Fmake_frame_invisible, 2);
2694EXFUN (Ficonify_frame, 1);
2695EXFUN (Fframe_visible_p, 1);
2696EXFUN (Fvisible_frame_list, 0);
2697EXFUN (Fframe_parameters, 1);
2698EXFUN (Fmodify_frame_parameters, 2);
2699EXFUN (Fset_frame_height, 3);
2700EXFUN (Fset_frame_width, 3);
2701EXFUN (Fset_frame_size, 3);
2702EXFUN (Fset_frame_position, 3);
2703EXFUN (Fraise_frame, 1);
2704EXFUN (Fredirect_frame_focus, 2);
2705EXFUN (Fset_frame_selected_window, 2);
2706extern Lisp_Object frame_buffer_list P_ ((Lisp_Object));
2707extern void frames_discard_buffer P_ ((Lisp_Object));
2708extern void set_frame_buffer_list P_ ((Lisp_Object, Lisp_Object));
2709extern void frames_bury_buffer P_ ((Lisp_Object));
2710extern void syms_of_frame P_ ((void));
2711extern void keys_of_frame P_ ((void));
2712
2713/* defined in emacs.c */
2714extern Lisp_Object decode_env_path P_ ((char *, char *));
2715extern Lisp_Object Vinvocation_name, Vinvocation_directory;
2716extern Lisp_Object Vinstallation_directory;
2717EXFUN (Fkill_emacs, 1);
2718#if HAVE_SETLOCALE
2719void fixup_locale P_ ((void));
2720void synchronize_system_messages_locale P_ ((void));
2721void synchronize_system_time_locale P_ ((void));
2722#else
2723#define setlocale(category, locale)
2724#define fixup_locale()
2725#define synchronize_system_messages_locale()
2726#define synchronize_system_time_locale()
2727#endif
2728void shut_down_emacs P_ ((int, int, Lisp_Object));
2729/* Nonzero means don't do interactive redisplay and don't change tty modes */
2730extern int noninteractive;
2731/* Nonzero means don't do use window-system-specific display code */
2732extern int inhibit_window_system;
2733/* Nonzero means that a filter or a sentinel is running. */
2734extern int running_asynch_code;
2735
2736/* defined in process.c */
2737EXFUN (Fget_process, 1);
2738EXFUN (Fget_buffer_process, 1);
2739EXFUN (Fprocessp, 1);
2740EXFUN (Fprocess_status, 1);
2741EXFUN (Fkill_process, 2);
2742EXFUN (Fprocess_send_eof, 1);
2743EXFUN (Fwaiting_for_user_input_p, 0);
2744extern Lisp_Object Qprocessp;
2745extern void kill_buffer_processes P_ ((Lisp_Object));
2746extern int wait_reading_process_input P_ ((int, int, Lisp_Object, int));
2747extern void deactivate_process P_ ((Lisp_Object));
2748extern void add_keyboard_wait_descriptor P_ ((int));
2749extern void delete_keyboard_wait_descriptor P_ ((int));
2750extern void close_process_descs P_ ((void));
2751extern void status_notify P_ ((void));
2752extern int read_process_output P_ ((Lisp_Object, int));
2753extern void init_process P_ ((void));
2754extern void syms_of_process P_ ((void));
2755
2756/* defined in callproc.c */
2757extern Lisp_Object Vexec_path, Vexec_directory, Vdata_directory;
2758extern Lisp_Object Vdoc_directory;
2759EXFUN (Fcall_process, MANY);
2760extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
2761extern void init_callproc_1 P_ ((void));
2762extern void init_callproc P_ ((void));
2763extern void set_process_environment P_ ((void));
2764extern void syms_of_callproc P_ ((void));
2765
2766/* defined in doc.c */
2767extern Lisp_Object Vdoc_file_name;
2768EXFUN (Fsubstitute_command_keys, 1);
2769EXFUN (Fdocumentation, 2);
2770EXFUN (Fdocumentation_property, 3);
2771extern Lisp_Object read_doc_string P_ ((Lisp_Object));
2772extern Lisp_Object get_doc_string P_ ((Lisp_Object, int, int));
2773extern void syms_of_doc P_ ((void));
2774extern int read_bytecode_char P_ ((int));
2775
2776/* defined in bytecode.c */
2777extern Lisp_Object Qbytecode;
2778EXFUN (Fbyte_code, 3);
2779extern void syms_of_bytecode P_ ((void));
2780extern struct byte_stack *byte_stack_list;
2781extern void mark_byte_stack P_ ((void));
2782extern void unmark_byte_stack P_ ((void));
2783
2784/* defined in macros.c */
2785extern Lisp_Object Qexecute_kbd_macro;
2786EXFUN (Fexecute_kbd_macro, 2);
2787extern void init_macros P_ ((void));
2788extern void syms_of_macros P_ ((void));
2789extern void keys_of_macros P_ ((void));
2790
2791/* defined in undo.c */
2792extern Lisp_Object Qinhibit_read_only;
2793EXFUN (Fundo_boundary, 0);
2794extern Lisp_Object truncate_undo_list P_ ((Lisp_Object, int, int));
2795extern void record_marker_adjustment P_ ((Lisp_Object, int));
2796extern void record_insert P_ ((int, int));
2797extern void record_delete P_ ((int, Lisp_Object));
2798extern void record_first_change P_ ((void));
2799extern void record_change P_ ((int, int));
2800extern void record_property_change P_ ((int, int, Lisp_Object, Lisp_Object,
2801 Lisp_Object));
2802extern void syms_of_undo P_ ((void));
2803
2804/* defined in textprop.c */
2805extern Lisp_Object Qmodification_hooks;
2806extern Lisp_Object Qrear_nonsticky, Qfont;
2807extern Lisp_Object Qinsert_in_front_hooks, Qinsert_behind_hooks;
2808EXFUN (Fnext_property_change, 3);
2809EXFUN (Fnext_single_property_change, 4);
2810EXFUN (Fnext_single_char_property_change, 4);
2811EXFUN (Fprevious_single_property_change, 4);
2812EXFUN (Fget_text_property, 3);
2813EXFUN (Fput_text_property, 5);
2814EXFUN (Fset_text_properties, 4);
2815EXFUN (Ftext_property_not_all, 5);
2816EXFUN (Fprevious_char_property_change, 2);
2817EXFUN (Fnext_char_property_change, 2);
2818extern void report_interval_modification P_ ((Lisp_Object, Lisp_Object));
2819extern void syms_of_textprop P_ ((void));
2820extern Lisp_Object next_single_char_property_change P_ ((Lisp_Object,
2821 Lisp_Object,
2822 Lisp_Object,
2823 Lisp_Object));
2824extern Lisp_Object set_text_properties P_ ((Lisp_Object, Lisp_Object,
2825 Lisp_Object, Lisp_Object,
2826 Lisp_Object));
2827
2828/* defined in xmenu.c */
2829EXFUN (Fx_popup_menu, 2);
2830EXFUN (Fx_popup_dialog, 2);
2831extern void syms_of_xmenu P_ ((void));
2832extern int popup_activated_flag;
2833
2834/* defined in sysdep.c */
2835extern void stuff_char P_ ((char c));
2836extern void init_sigio P_ ((int));
2837extern void request_sigio P_ ((void));
2838extern void unrequest_sigio P_ ((void));
2839extern void reset_sys_modes P_ ((void));
2840extern void sys_subshell P_ ((void));
2841extern void sys_suspend P_ ((void));
2842extern void discard_tty_input P_ ((void));
2843extern void init_sys_modes P_ ((void));
2844extern void reset_sys_modes P_ ((void));
2845extern void get_frame_size P_ ((int *, int *));
2846extern void wait_for_termination P_ ((int));
2847extern void flush_pending_output P_ ((int));
2848extern void child_setup_tty P_ ((int));
2849extern void setup_pty P_ ((int));
2850extern int set_window_size P_ ((int, int, int));
2851extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
2852extern int tabs_safe_p P_ ((void));
2853extern void init_baud_rate P_ ((void));
2854extern int emacs_open P_ ((char *, int, int));
2855extern int emacs_close P_ ((int));
2856extern int emacs_read P_ ((int, char *, unsigned int));
2857extern int emacs_write P_ ((int, char *, unsigned int));
2858
2859/* defined in filelock.c */
2860EXFUN (Funlock_buffer, 0);
2861EXFUN (Ffile_locked_p, 1);
2862extern void unlock_all_files P_ ((void));
2863extern void lock_file P_ ((Lisp_Object));
2864extern void unlock_file P_ ((Lisp_Object));
2865extern void unlock_buffer P_ ((struct buffer *));
2866extern void syms_of_filelock P_ ((void));
2867extern void init_filelock P_ ((void));
2868
2869/* Defined in sound.c */
2870extern void syms_of_sound P_ ((void));
2871extern void init_sound P_ ((void));
2872
2873/* Defined in category.c */
2874extern void init_category_once P_ ((void));
2875extern void syms_of_category P_ ((void));
2876
2877/* Defined in ccl.c */
2878extern void syms_of_ccl P_ ((void));
2879
2880/* Defined in dired.c */
2881EXFUN (Ffile_attributes, 1);
2882extern void syms_of_dired P_ ((void));
2883
2884/* Defined in mocklisp.c */
2885extern void syms_of_mocklisp P_ ((void));
2886
2887/* Defined in term.c */
2888extern void syms_of_term P_ ((void));
2889extern void fatal () NO_RETURN;
2890
2891#ifdef HAVE_X_WINDOWS
2892/* Defined in fontset.c */
2893extern void syms_of_fontset P_ ((void));
2894EXFUN (Fset_fontset_font, 4);
2895#endif
2896
2897/* Defined in xfaces.c */
2898extern void syms_of_xfaces P_ ((void));
2899
2900/* Defined in getloadavg.c */
2901extern int getloadavg P_ ((double *, int));
2902
2903#ifdef HAVE_X_WINDOWS
2904/* Defined in xfns.c */
2905extern void syms_of_xfns P_ ((void));
2906extern void init_xfns P_ ((void));
2907EXFUN (Fxw_display_color_p, 1);
2908#endif /* HAVE_X_WINDOWS */
2909
2910/* Defined in xselect.c */
2911extern void syms_of_xselect P_ ((void));
2912
2913/* Defined in xterm.c */
2914extern void syms_of_xterm P_ ((void));
2915
2916/* Defined in getloadavg.c */
2917extern int getloadavg P_ ((double [], int));
2918\f
2919/* Nonzero means Emacs has already been initialized.
2920 Used during startup to detect startup of dumped Emacs. */
2921extern int initialized;
2922
2923extern int immediate_quit; /* Nonzero means ^G can quit instantly */
2924
2925extern POINTER_TYPE *xmalloc P_ ((size_t));
2926extern POINTER_TYPE *xrealloc P_ ((POINTER_TYPE *, size_t));
2927extern void xfree P_ ((POINTER_TYPE *));
2928
2929extern char *xstrdup P_ ((char *));
2930
2931#ifndef USE_CRT_DLL
2932extern char *egetenv P_ ((char *));
2933#endif
2934
2935/* Set up the name of the machine we're running on. */
2936extern void init_system_name P_ ((void));
2937
2938/* Some systems (e.g., NT) use a different path separator than Unix,
2939 in addition to a device separator. Default the path separator
2940 to '/', and don't test for a device separator in IS_ANY_SEP. */
2941
2942#ifdef WINDOWSNT
2943extern Lisp_Object Vdirectory_sep_char;
2944#endif
2945
2946#ifndef DIRECTORY_SEP
2947#define DIRECTORY_SEP '/'
2948#endif
2949#ifndef IS_DIRECTORY_SEP
2950#define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
2951#endif
2952#ifndef IS_DEVICE_SEP
2953#ifndef DEVICE_SEP
2954#define IS_DEVICE_SEP(_c_) 0
2955#else
2956#define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
2957#endif
2958#endif
2959#ifndef IS_ANY_SEP
2960#define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
2961#endif
2962
2963#ifdef SWITCH_ENUM_BUG
2964#define SWITCH_ENUM_CAST(x) ((int)(x))
2965#else
2966#define SWITCH_ENUM_CAST(x) (x)
2967#endif
Unnamed repository; edit this file 'description' to name the repository.