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