1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989,
3 1993 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include <sys/types.h>
35 #include "termhooks.h"
39 #include <sys/inode.h>
46 #ifdef LISP_FLOAT_TYPE
51 #if 0 /* That is untrue--XINT is used below, and it uses INTBITS.
52 What in the world is values.h, anyway? */
54 /* These are redefined in <values.h> and not used here */
62 #endif /* LISP_FLOAT_TYPE */
64 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
65 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
66 Lisp_Object Qascii_character
, Qload
;
68 extern Lisp_Object Qevent_symbol_element_mask
;
70 /* non-zero if inside `load' */
73 /* Search path for files to be loaded. */
74 Lisp_Object Vload_path
;
76 /* This is the user-visible association list that maps features to
77 lists of defs in their load files. */
78 Lisp_Object Vload_history
;
80 /* This is useud to build the load history. */
81 Lisp_Object Vcurrent_load_list
;
83 /* List of descriptors now open for Fload. */
84 static Lisp_Object load_descriptor_list
;
86 /* File for get_file_char to read from. Use by load */
87 static FILE *instream
;
89 /* When nonzero, read conses in pure space */
92 /* For use within read-from-string (this reader is non-reentrant!!) */
93 static int read_from_string_index
;
94 static int read_from_string_limit
;
96 /* Handle unreading and rereading of characters.
97 Write READCHAR to read a character,
98 UNREAD(c) to unread c to be read again. */
100 #define READCHAR readchar (readcharfun)
101 #define UNREAD(c) unreadchar (readcharfun, c)
104 readchar (readcharfun
)
105 Lisp_Object readcharfun
;
108 register struct buffer
*inbuffer
;
109 register int c
, mpos
;
111 if (XTYPE (readcharfun
) == Lisp_Buffer
)
113 inbuffer
= XBUFFER (readcharfun
);
115 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
117 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
118 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
122 if (XTYPE (readcharfun
) == Lisp_Marker
)
124 inbuffer
= XMARKER (readcharfun
)->buffer
;
126 mpos
= marker_position (readcharfun
);
128 if (mpos
> BUF_ZV (inbuffer
) - 1)
130 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
131 if (mpos
!= BUF_GPT (inbuffer
))
132 XMARKER (readcharfun
)->bufpos
++;
134 Fset_marker (readcharfun
, make_number (mpos
+ 1),
135 Fmarker_buffer (readcharfun
));
138 if (EQ (readcharfun
, Qget_file_char
))
139 return getc (instream
);
141 if (XTYPE (readcharfun
) == Lisp_String
)
144 /* This used to be return of a conditional expression,
145 but that truncated -1 to a char on VMS. */
146 if (read_from_string_index
< read_from_string_limit
)
147 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
153 tem
= call0 (readcharfun
);
160 /* Unread the character C in the way appropriate for the stream READCHARFUN.
161 If the stream is a user function, call it with the char as argument. */
164 unreadchar (readcharfun
, c
)
165 Lisp_Object readcharfun
;
168 if (XTYPE (readcharfun
) == Lisp_Buffer
)
170 if (XBUFFER (readcharfun
) == current_buffer
)
173 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
175 else if (XTYPE (readcharfun
) == Lisp_Marker
)
176 XMARKER (readcharfun
)->bufpos
--;
177 else if (XTYPE (readcharfun
) == Lisp_String
)
178 read_from_string_index
--;
179 else if (EQ (readcharfun
, Qget_file_char
))
180 ungetc (c
, instream
);
182 call1 (readcharfun
, make_number (c
));
185 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
187 /* get a character from the tty */
189 extern Lisp_Object
read_char ();
191 /* Read input events until we get one that's acceptable for our purposes.
193 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
194 until we get a character we like, and then stuffed into
197 If ASCII_REQUIRED is non-zero, we check function key events to see
198 if the unmodified version of the symbol has a Qascii_character
199 property, and use that character, if present.
201 If ERROR_NONASCII is non-zero, we signal an error if the input we
202 get isn't an ASCII character with modifiers. If it's zero but
203 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
206 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
207 int no_switch_frame
, ascii_required
, error_nonascii
;
210 return make_number (getchar ());
212 register Lisp_Object val
;
213 register Lisp_Object delayed_switch_frame
= Qnil
;
215 /* Read until we get an acceptable event. */
217 val
= read_char (0, 0, 0, Qnil
, 0);
219 if (XTYPE (val
) == Lisp_Buffer
)
222 /* switch-frame events are put off until after the next ASCII
223 character. This is better than signalling an error just because
224 the last characters were typed to a separate minibuffer frame,
225 for example. Eventually, some code which can deal with
226 switch-frame events will read it and process it. */
228 && EVENT_HAS_PARAMETERS (val
)
229 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
231 delayed_switch_frame
= val
;
237 /* Convert certain symbols to their ASCII equivalents. */
238 if (XTYPE (val
) == Lisp_Symbol
)
240 Lisp_Object tem
, tem1
, tem2
;
241 tem
= Fget (val
, Qevent_symbol_element_mask
);
244 tem1
= Fget (Fcar (tem
), Qascii_character
);
245 /* Merge this symbol's modifier bits
246 with the ASCII equivalent of its basic code. */
248 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
252 /* If we don't have a character now, deal with it appropriately. */
253 if (XTYPE (val
) != Lisp_Int
)
257 unread_command_events
= Fcons (val
, Qnil
);
258 error ("Non-character input-event");
265 if (! NILP (delayed_switch_frame
))
266 unread_switch_frame
= delayed_switch_frame
;
272 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
273 "Read a character from the command input (keyboard or macro).\n\
274 It is returned as a number.\n\
275 If the user generates an event which is not a character (i.e. a mouse\n\
276 click or function key event), `read-char' signals an error. As an\n\
277 exception, switch-frame events are put off until non-ASCII events can\n\
279 If you want to read non-character events, or ignore them, call\n\
280 `read-event' or `read-char-exclusive' instead.")
283 return read_filtered_event (1, 1, 1);
286 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
287 "Read an event object from the input stream.")
290 return read_filtered_event (0, 0, 0);
293 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
294 "Read a character from the command input (keyboard or macro).\n\
295 It is returned as a number. Non character events are ignored.")
298 return read_filtered_event (1, 1, 0);
301 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
302 "Don't use this yourself.")
305 register Lisp_Object val
;
306 XSET (val
, Lisp_Int
, getc (instream
));
310 static void readevalloop ();
311 static Lisp_Object
load_unwind ();
312 static Lisp_Object
load_descriptor_unwind ();
314 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
315 "Execute a file of Lisp code named FILE.\n\
316 First try FILE with `.elc' appended, then try with `.el',\n\
317 then try FILE unmodified.\n\
318 This function searches the directories in `load-path'.\n\
319 If optional second arg NOERROR is non-nil,\n\
320 report no error if FILE doesn't exist.\n\
321 Print messages at start and end of loading unless\n\
322 optional third arg NOMESSAGE is non-nil.\n\
323 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
324 suffixes `.elc' or `.el' to the specified name FILE.\n\
325 Return t if file exists.")
326 (str
, noerror
, nomessage
, nosuffix
)
327 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
329 register FILE *stream
;
330 register int fd
= -1;
331 register Lisp_Object lispstream
;
333 int count
= specpdl_ptr
- specpdl
;
337 /* 1 means inhibit the message at the beginning. */
341 char *dosmode
= "rt";
344 CHECK_STRING (str
, 0);
345 str
= Fsubstitute_in_file_name (str
);
347 /* If file name is magic, call the handler. */
348 handler
= Ffind_file_name_handler (str
);
350 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
352 /* Avoid weird lossage with null string as arg,
353 since it would try to load a directory as a Lisp file */
354 if (XSTRING (str
)->size
> 0)
357 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
366 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
372 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
381 stat ((char *)XSTRING (found
)->data
, &s1
);
382 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
383 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
384 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
386 message ("Source file `%s' newer than byte-compiled file",
387 XSTRING (found
)->data
);
388 /* Don't immediately overwrite this message. */
392 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
397 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
399 stream
= fdopen (fd
, "r");
404 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
407 if (NILP (nomessage
) && !nomessage1
)
408 message ("Loading %s...", XSTRING (str
)->data
);
411 /* We may not be able to store STREAM itself as a Lisp_Object pointer
412 since that is guaranteed to work only for data that has been malloc'd.
413 So malloc a full-size pointer, and record the address of that pointer. */
414 ptr
= (FILE **) xmalloc (sizeof (FILE *));
416 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
417 record_unwind_protect (load_unwind
, lispstream
);
418 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
420 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
422 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
423 unbind_to (count
, Qnil
);
425 /* Run any load-hooks for this file. */
426 temp
= Fassoc (str
, Vafter_load_alist
);
428 Fprogn (Fcdr (temp
));
431 if (!noninteractive
&& NILP (nomessage
))
432 message ("Loading %s...done", XSTRING (str
)->data
);
437 load_unwind (stream
) /* used as unwind-protect function in load */
440 fclose (*(FILE **) XSTRING (stream
));
441 xfree (XPNTR (stream
));
442 if (--load_in_progress
< 0) load_in_progress
= 0;
447 load_descriptor_unwind (oldlist
)
450 load_descriptor_list
= oldlist
;
453 /* Close all descriptors in use for Floads.
454 This is used when starting a subprocess. */
460 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
461 close (XFASTINT (XCONS (tail
)->car
));
465 complete_filename_p (pathname
)
466 Lisp_Object pathname
;
468 register unsigned char *s
= XSTRING (pathname
)->data
;
476 #ifdef MSDOS /* MW, May 1993 */
477 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
482 /* Search for a file whose name is STR, looking in directories
483 in the Lisp list PATH, and trying suffixes from SUFFIX.
484 SUFFIX is a string containing possible suffixes separated by colons.
485 On success, returns a file descriptor. On failure, returns -1.
487 EXEC_ONLY nonzero means don't open the files,
488 just look for one that is executable. In this case,
489 returns 1 on success.
491 If STOREPTR is nonzero, it points to a slot where the name of
492 the file actually found should be stored as a Lisp string.
493 Nil is stored there on failure. */
496 openp (path
, str
, suffix
, storeptr
, exec_only
)
497 Lisp_Object path
, str
;
499 Lisp_Object
*storeptr
;
505 register char *fn
= buf
;
508 register Lisp_Object filename
;
516 if (complete_filename_p (str
))
519 for (; !NILP (path
); path
= Fcdr (path
))
523 filename
= Fexpand_file_name (str
, Fcar (path
));
524 if (!complete_filename_p (filename
))
525 /* If there are non-absolute elts in PATH (eg ".") */
526 /* Of course, this could conceivably lose if luser sets
527 default-directory to be something non-absolute... */
529 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
530 if (!complete_filename_p (filename
))
531 /* Give up on this path element! */
535 /* Calculate maximum size of any filename made from
536 this path element/specified file name and any possible suffix. */
537 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
538 if (fn_size
< want_size
)
539 fn
= (char *) alloca (fn_size
= 100 + want_size
);
543 /* Loop over suffixes. */
546 char *esuffix
= (char *) index (nsuffix
, ':');
547 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
549 /* Concatenate path element/specified name with the suffix. */
550 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
551 fn
[XSTRING (filename
)->size
] = 0;
552 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
553 strncat (fn
, nsuffix
, lsuffix
);
555 /* Ignore file if it's a directory. */
556 if (stat (fn
, &st
) >= 0
557 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
559 /* Check that we can access or open it. */
561 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
563 fd
= open (fn
, 0, 0);
567 /* We succeeded; return this descriptor and filename. */
569 *storeptr
= build_string (fn
);
574 /* Advance to next suffix. */
577 nsuffix
+= lsuffix
+ 1;
587 /* Merge the list we've accumulated of globals from the current input source
588 into the load_history variable. The details depend on whether
589 the source has an associated file name or not. */
592 build_load_history (stream
, source
)
596 register Lisp_Object tail
, prev
, newelt
;
597 register Lisp_Object tem
, tem2
;
598 register int foundit
, loading
;
600 /* Don't bother recording anything for preloaded files. */
601 if (!NILP (Vpurify_flag
))
604 loading
= stream
|| !NARROWED
;
606 tail
= Vload_history
;
613 /* Find the feature's previous assoc list... */
614 if (!NILP (Fequal (source
, Fcar (tem
))))
618 /* If we're loading, remove it. */
622 Vload_history
= Fcdr (tail
);
624 Fsetcdr (prev
, Fcdr (tail
));
627 /* Otherwise, cons on new symbols that are not already members. */
630 tem2
= Vcurrent_load_list
;
634 newelt
= Fcar (tem2
);
636 if (NILP (Fmemq (newelt
, tem
)))
637 Fsetcar (tail
, Fcons (Fcar (tem
),
638 Fcons (newelt
, Fcdr (tem
))));
651 /* If we're loading, cons the new assoc onto the front of load-history,
652 the most-recently-loaded position. Also do this if we didn't find
653 an existing member for the current source. */
654 if (loading
|| !foundit
)
655 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
660 unreadpure () /* Used as unwind-protect function in readevalloop */
667 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
668 Lisp_Object readcharfun
;
670 Lisp_Object sourcename
;
671 Lisp_Object (*evalfun
) ();
675 register Lisp_Object val
;
676 int count
= specpdl_ptr
- specpdl
;
678 struct buffer
*b
= 0;
680 if (BUFFERP (readcharfun
))
681 b
= XBUFFER (readcharfun
);
682 else if (MARKERP (readcharfun
))
683 b
= XMARKER (readcharfun
)->buffer
;
685 specbind (Qstandard_input
, readcharfun
);
686 specbind (Qcurrent_load_list
, Qnil
);
690 LOADHIST_ATTACH (sourcename
);
694 if (b
!= 0 && NILP (b
->name
))
695 error ("Reading from killed buffer");
701 while ((c
= READCHAR
) != '\n' && c
!= -1);
705 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
707 if (!NILP (Vpurify_flag
) && c
== '(')
709 record_unwind_protect (unreadpure
, Qnil
);
710 val
= read_list (-1, readcharfun
);
711 unbind_to (count
+ 1, Qnil
);
716 val
= read0 (readcharfun
);
719 val
= (*evalfun
) (val
);
722 Vvalues
= Fcons (val
, Vvalues
);
723 if (EQ (Vstandard_output
, Qt
))
730 build_load_history (stream
, sourcename
);
733 unbind_to (count
, Qnil
);
738 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
739 "Execute the current buffer as Lisp code.\n\
740 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
741 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
742 PRINTFLAG controls printing of output:\n\
743 nil means discard it; anything else is stream for print.\n\
745 If there is no error, point does not move. If there is an error,\n\
746 point remains at the end of the last character read from the buffer.")
748 Lisp_Object bufname
, printflag
;
750 int count
= specpdl_ptr
- specpdl
;
751 Lisp_Object tem
, buf
;
754 buf
= Fcurrent_buffer ();
756 buf
= Fget_buffer (bufname
);
758 error ("No such buffer.");
760 if (NILP (printflag
))
764 specbind (Qstandard_output
, tem
);
765 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
766 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
767 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
768 unbind_to (count
, Qnil
);
774 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
775 "Execute the current buffer as Lisp code.\n\
776 Programs can pass argument PRINTFLAG which controls printing of output:\n\
777 nil means discard it; anything else is stream for print.\n\
779 If there is no error, point does not move. If there is an error,\n\
780 point remains at the end of the last character read from the buffer.")
782 Lisp_Object printflag
;
784 int count
= specpdl_ptr
- specpdl
;
785 Lisp_Object tem
, cbuf
;
787 cbuf
= Fcurrent_buffer ()
789 if (NILP (printflag
))
793 specbind (Qstandard_output
, tem
);
794 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
796 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
797 return unbind_to (count
, Qnil
);
801 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
802 "Execute the region as Lisp code.\n\
803 When called from programs, expects two arguments,\n\
804 giving starting and ending indices in the current buffer\n\
805 of the text to be executed.\n\
806 Programs can pass third argument PRINTFLAG which controls output:\n\
807 nil means discard it; anything else is stream for printing it.\n\
809 If there is no error, point does not move. If there is an error,\n\
810 point remains at the end of the last character read from the buffer.")
812 Lisp_Object b
, e
, printflag
;
814 int count
= specpdl_ptr
- specpdl
;
815 Lisp_Object tem
, cbuf
;
817 cbuf
= Fcurrent_buffer ();
819 if (NILP (printflag
))
823 specbind (Qstandard_output
, tem
);
825 if (NILP (printflag
))
826 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
827 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
829 /* This both uses b and checks its type. */
831 Fnarrow_to_region (make_number (BEGV
), e
);
832 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
834 return unbind_to (count
, Qnil
);
837 #endif /* standalone */
839 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
840 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
841 If STREAM is nil, use the value of `standard-input' (which see).\n\
842 STREAM or the value of `standard-input' may be:\n\
843 a buffer (read from point and advance it)\n\
844 a marker (read from where it points and advance it)\n\
845 a function (call it with no arguments for each character,\n\
846 call it with a char as argument to push a char back)\n\
847 a string (takes text from string, starting at the beginning)\n\
848 t (read text line using minibuffer and use it).")
850 Lisp_Object readcharfun
;
852 extern Lisp_Object
Fread_minibuffer ();
854 if (NILP (readcharfun
))
855 readcharfun
= Vstandard_input
;
856 if (EQ (readcharfun
, Qt
))
857 readcharfun
= Qread_char
;
860 if (EQ (readcharfun
, Qread_char
))
861 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
864 if (XTYPE (readcharfun
) == Lisp_String
)
865 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
867 return read0 (readcharfun
);
870 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
871 "Read one Lisp expression which is represented as text by STRING.\n\
872 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
873 START and END optionally delimit a substring of STRING from which to read;\n\
874 they default to 0 and (length STRING) respectively.")
876 Lisp_Object string
, start
, end
;
878 int startval
, endval
;
881 CHECK_STRING (string
,0);
884 endval
= XSTRING (string
)->size
;
886 { CHECK_NUMBER (end
,2);
888 if (endval
< 0 || endval
> XSTRING (string
)->size
)
889 args_out_of_range (string
, end
);
895 { CHECK_NUMBER (start
,1);
896 startval
= XINT (start
);
897 if (startval
< 0 || startval
> endval
)
898 args_out_of_range (string
, start
);
901 read_from_string_index
= startval
;
902 read_from_string_limit
= endval
;
904 tem
= read0 (string
);
905 return Fcons (tem
, make_number (read_from_string_index
));
908 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
912 Lisp_Object readcharfun
;
914 register Lisp_Object val
;
917 val
= read1 (readcharfun
);
918 if (XTYPE (val
) == Lisp_Internal
)
921 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
927 static int read_buffer_size
;
928 static char *read_buffer
;
931 read_escape (readcharfun
)
932 Lisp_Object readcharfun
;
934 register int c
= READCHAR
;
961 error ("Invalid escape character syntax");
964 c
= read_escape (readcharfun
);
965 return c
| meta_modifier
;
970 error ("Invalid escape character syntax");
973 c
= read_escape (readcharfun
);
974 return c
| shift_modifier
;
979 error ("Invalid escape character syntax");
982 c
= read_escape (readcharfun
);
983 return c
| hyper_modifier
;
988 error ("Invalid escape character syntax");
991 c
= read_escape (readcharfun
);
992 return c
| alt_modifier
;
997 error ("Invalid escape character syntax");
1000 c
= read_escape (readcharfun
);
1001 return c
| super_modifier
;
1006 error ("Invalid escape character syntax");
1010 c
= read_escape (readcharfun
);
1011 if ((c
& 0177) == '?')
1013 /* ASCII control chars are made from letters (both cases),
1014 as well as the non-letters within 0100...0137. */
1015 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1016 return (c
& (037 | ~0177));
1017 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1018 return (c
& (037 | ~0177));
1020 return c
| ctrl_modifier
;
1030 /* An octal escape, as in ANSI C. */
1032 register int i
= c
- '0';
1033 register int count
= 0;
1036 if ((c
= READCHAR
) >= '0' && c
<= '7')
1051 /* A hex escape, as in ANSI C. */
1057 if (c
>= '0' && c
<= '9')
1062 else if ((c
>= 'a' && c
<= 'f')
1063 || (c
>= 'A' && c
<= 'F'))
1066 if (c
>= 'a' && c
<= 'f')
1087 register Lisp_Object readcharfun
;
1094 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1099 return read_list (0, readcharfun
);
1102 return read_vector (readcharfun
);
1107 register Lisp_Object val
;
1108 XSET (val
, Lisp_Internal
, c
);
1116 /* Accept compiled functions at read-time so that we don't have to
1117 build them using function calls. */
1119 tmp
= read_vector (readcharfun
);
1120 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1121 XVECTOR (tmp
)->contents
);
1123 #ifdef USE_TEXT_PROPERTIES
1127 struct gcpro gcpro1
;
1129 /* Read the string itself. */
1130 tmp
= read1 (readcharfun
);
1131 if (XTYPE (tmp
) != Lisp_String
)
1132 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1134 /* Read the intervals and their properties. */
1137 Lisp_Object beg
, end
, plist
;
1139 beg
= read1 (readcharfun
);
1140 if (XTYPE (beg
) == Lisp_Internal
)
1142 if (XINT (beg
) == ')')
1144 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1146 end
= read1 (readcharfun
);
1147 if (XTYPE (end
) == Lisp_Internal
)
1148 Fsignal (Qinvalid_read_syntax
,
1149 Fcons (make_string ("invalid string property list", 28), Qnil
));
1151 plist
= read1 (readcharfun
);
1152 if (XTYPE (plist
) == Lisp_Internal
)
1153 Fsignal (Qinvalid_read_syntax
,
1154 Fcons (make_string ("invalid string property list", 28), Qnil
));
1155 Fset_text_properties (beg
, end
, plist
, tmp
);
1162 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1165 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1170 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1175 register Lisp_Object val
;
1178 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1181 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1183 XSET (val
, Lisp_Int
, c
);
1190 register char *p
= read_buffer
;
1191 register char *end
= read_buffer
+ read_buffer_size
;
1195 while ((c
= READCHAR
) >= 0
1200 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1201 p
+= new - read_buffer
;
1202 read_buffer
+= new - read_buffer
;
1203 end
= read_buffer
+ read_buffer_size
;
1206 c
= read_escape (readcharfun
);
1207 /* c is -1 if \ newline has just been seen */
1210 if (p
== read_buffer
)
1213 else if (c
& CHAR_META
)
1214 /* Move the meta bit to the right place for a string. */
1215 *p
++ = (c
& ~CHAR_META
) | 0x80;
1219 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1221 /* If purifying, and string starts with \ newline,
1222 return zero instead. This is for doc strings
1223 that we are really going to find in etc/DOC.nn.nn */
1224 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1225 return make_number (0);
1228 return make_pure_string (read_buffer
, p
- read_buffer
);
1230 return make_string (read_buffer
, p
- read_buffer
);
1235 #ifdef LISP_FLOAT_TYPE
1236 /* If a period is followed by a number, then we should read it
1237 as a floating point number. Otherwise, it denotes a dotted
1239 int next_char
= READCHAR
;
1242 if (! isdigit (next_char
))
1245 register Lisp_Object val
;
1246 XSET (val
, Lisp_Internal
, c
);
1250 /* Otherwise, we fall through! Note that the atom-reading loop
1251 below will now loop at least once, assuring that we will not
1252 try to UNREAD two characters in a row. */
1255 if (c
<= 040) goto retry
;
1257 register char *p
= read_buffer
;
1261 register char *end
= read_buffer
+ read_buffer_size
;
1264 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1265 || c
== '(' || c
== ')'
1266 #ifndef LISP_FLOAT_TYPE
1267 /* If we have floating-point support, then we need
1268 to allow <digits><dot><digits>. */
1270 #endif /* not LISP_FLOAT_TYPE */
1271 || c
== '[' || c
== ']' || c
== '#'
1276 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1277 p
+= new - read_buffer
;
1278 read_buffer
+= new - read_buffer
;
1279 end
= read_buffer
+ read_buffer_size
;
1292 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1293 p
+= new - read_buffer
;
1294 read_buffer
+= new - read_buffer
;
1295 /* end = read_buffer + read_buffer_size; */
1305 register Lisp_Object val
;
1307 if (*p1
== '+' || *p1
== '-') p1
++;
1308 /* Is it an integer? */
1311 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1312 #ifdef LISP_FLOAT_TYPE
1313 /* Integers can have trailing decimal points. */
1314 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1317 /* It is an integer. */
1319 #ifdef LISP_FLOAT_TYPE
1323 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1327 #ifdef LISP_FLOAT_TYPE
1328 if (isfloat_string (read_buffer
))
1329 return make_float (atof (read_buffer
));
1333 return intern (read_buffer
);
1338 #ifdef LISP_FLOAT_TYPE
1353 if (*cp
== '+' || *cp
== '-')
1359 while (isdigit (*cp
))
1370 while (isdigit (*cp
))
1378 if ((*cp
== '+') || (*cp
== '-'))
1384 while (isdigit (*cp
))
1388 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1389 || state
== (DOT_CHAR
|TRAIL_INT
)
1390 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1391 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1392 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1394 #endif /* LISP_FLOAT_TYPE */
1397 read_vector (readcharfun
)
1398 Lisp_Object readcharfun
;
1402 register Lisp_Object
*ptr
;
1403 register Lisp_Object tem
, vector
;
1404 register struct Lisp_Cons
*otem
;
1407 tem
= read_list (1, readcharfun
);
1408 len
= Flength (tem
);
1409 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1412 size
= XVECTOR (vector
)->size
;
1413 ptr
= XVECTOR (vector
)->contents
;
1414 for (i
= 0; i
< size
; i
++)
1416 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1424 /* flag = 1 means check for ] to terminate rather than ) and .
1425 flag = -1 means check for starting with defun
1426 and make structure pure. */
1429 read_list (flag
, readcharfun
)
1431 register Lisp_Object readcharfun
;
1433 /* -1 means check next element for defun,
1434 0 means don't check,
1435 1 means already checked and found defun. */
1436 int defunflag
= flag
< 0 ? -1 : 0;
1437 Lisp_Object val
, tail
;
1438 register Lisp_Object elt
, tem
;
1439 struct gcpro gcpro1
, gcpro2
;
1447 elt
= read1 (readcharfun
);
1449 if (XTYPE (elt
) == Lisp_Internal
)
1453 if (XINT (elt
) == ']')
1455 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1457 if (XINT (elt
) == ')')
1459 if (XINT (elt
) == '.')
1463 XCONS (tail
)->cdr
= read0 (readcharfun
);
1465 val
= read0 (readcharfun
);
1466 elt
= read1 (readcharfun
);
1468 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1470 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1472 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1474 tem
= (read_pure
&& flag
<= 0
1475 ? pure_cons (elt
, Qnil
)
1476 : Fcons (elt
, Qnil
));
1478 XCONS (tail
)->cdr
= tem
;
1483 defunflag
= EQ (elt
, Qdefun
);
1484 else if (defunflag
> 0)
1489 Lisp_Object Vobarray
;
1490 Lisp_Object initial_obarray
;
1493 check_obarray (obarray
)
1494 Lisp_Object obarray
;
1496 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1498 /* If Vobarray is now invalid, force it to be valid. */
1499 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1501 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1506 static int hash_string ();
1507 Lisp_Object
oblookup ();
1514 int len
= strlen (str
);
1515 Lisp_Object obarray
= Vobarray
;
1517 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1518 obarray
= check_obarray (obarray
);
1519 tem
= oblookup (obarray
, str
, len
);
1520 if (XTYPE (tem
) == Lisp_Symbol
)
1522 return Fintern ((!NILP (Vpurify_flag
)
1523 ? make_pure_string (str
, len
)
1524 : make_string (str
, len
)),
1528 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1529 "Return the canonical symbol whose name is STRING.\n\
1530 If there is none, one is created by this function and returned.\n\
1531 A second optional argument specifies the obarray to use;\n\
1532 it defaults to the value of `obarray'.")
1534 Lisp_Object str
, obarray
;
1536 register Lisp_Object tem
, sym
, *ptr
;
1538 if (NILP (obarray
)) obarray
= Vobarray
;
1539 obarray
= check_obarray (obarray
);
1541 CHECK_STRING (str
, 0);
1543 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1544 if (XTYPE (tem
) != Lisp_Int
)
1547 if (!NILP (Vpurify_flag
))
1548 str
= Fpurecopy (str
);
1549 sym
= Fmake_symbol (str
);
1551 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1552 if (XTYPE (*ptr
) == Lisp_Symbol
)
1553 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1555 XSYMBOL (sym
)->next
= 0;
1560 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1561 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1562 A second optional argument specifies the obarray to use;\n\
1563 it defaults to the value of `obarray'.")
1565 Lisp_Object str
, obarray
;
1567 register Lisp_Object tem
;
1569 if (NILP (obarray
)) obarray
= Vobarray
;
1570 obarray
= check_obarray (obarray
);
1572 CHECK_STRING (str
, 0);
1574 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1575 if (XTYPE (tem
) != Lisp_Int
)
1581 oblookup (obarray
, ptr
, size
)
1582 Lisp_Object obarray
;
1587 register Lisp_Object tail
;
1588 Lisp_Object bucket
, tem
;
1590 if (XTYPE (obarray
) != Lisp_Vector
1591 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1593 obarray
= check_obarray (obarray
);
1594 obsize
= XVECTOR (obarray
)->size
;
1596 /* Combining next two lines breaks VMS C 2.3. */
1597 hash
= hash_string (ptr
, size
);
1599 bucket
= XVECTOR (obarray
)->contents
[hash
];
1600 if (XFASTINT (bucket
) == 0)
1602 else if (XTYPE (bucket
) != Lisp_Symbol
)
1603 error ("Bad data in guts of obarray"); /* Like CADR error message */
1604 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1606 if (XSYMBOL (tail
)->name
->size
== size
&&
1607 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1609 else if (XSYMBOL (tail
)->next
== 0)
1612 XSET (tem
, Lisp_Int
, hash
);
1617 hash_string (ptr
, len
)
1621 register unsigned char *p
= ptr
;
1622 register unsigned char *end
= p
+ len
;
1623 register unsigned char c
;
1624 register int hash
= 0;
1629 if (c
>= 0140) c
-= 40;
1630 hash
= ((hash
<<3) + (hash
>>28) + c
);
1632 return hash
& 07777777777;
1636 map_obarray (obarray
, fn
, arg
)
1637 Lisp_Object obarray
;
1642 register Lisp_Object tail
;
1643 CHECK_VECTOR (obarray
, 1);
1644 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1646 tail
= XVECTOR (obarray
)->contents
[i
];
1647 if (XFASTINT (tail
) != 0)
1651 if (XSYMBOL (tail
)->next
== 0)
1653 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1658 mapatoms_1 (sym
, function
)
1659 Lisp_Object sym
, function
;
1661 call1 (function
, sym
);
1664 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1665 "Call FUNCTION on every symbol in OBARRAY.\n\
1666 OBARRAY defaults to the value of `obarray'.")
1668 Lisp_Object function
, obarray
;
1672 if (NILP (obarray
)) obarray
= Vobarray
;
1673 obarray
= check_obarray (obarray
);
1675 map_obarray (obarray
, mapatoms_1
, function
);
1679 #define OBARRAY_SIZE 1511
1684 Lisp_Object oblength
;
1688 XFASTINT (oblength
) = OBARRAY_SIZE
;
1690 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1691 Vobarray
= Fmake_vector (oblength
, make_number (0));
1692 initial_obarray
= Vobarray
;
1693 staticpro (&initial_obarray
);
1694 /* Intern nil in the obarray */
1695 /* These locals are to kludge around a pyramid compiler bug. */
1696 hash
= hash_string ("nil", 3);
1697 /* Separate statement here to avoid VAXC bug. */
1698 hash
%= OBARRAY_SIZE
;
1699 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1702 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1703 XSYMBOL (Qnil
)->function
= Qunbound
;
1704 XSYMBOL (Qunbound
)->value
= Qunbound
;
1705 XSYMBOL (Qunbound
)->function
= Qunbound
;
1708 XSYMBOL (Qnil
)->value
= Qnil
;
1709 XSYMBOL (Qnil
)->plist
= Qnil
;
1710 XSYMBOL (Qt
)->value
= Qt
;
1712 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1715 Qvariable_documentation
= intern ("variable-documentation");
1717 read_buffer_size
= 100;
1718 read_buffer
= (char *) malloc (read_buffer_size
);
1723 struct Lisp_Subr
*sname
;
1726 sym
= intern (sname
->symbol_name
);
1727 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1730 #ifdef NOTDEF /* use fset in subr.el now */
1732 defalias (sname
, string
)
1733 struct Lisp_Subr
*sname
;
1737 sym
= intern (string
);
1738 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1742 /* New replacement for DefIntVar; it ignores the doc string argument
1743 on the assumption that make-docfile will handle that. */
1744 /* Define an "integer variable"; a symbol whose value is forwarded
1745 to a C variable of type int. Sample call: */
1746 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1749 defvar_int (namestring
, address
, doc
)
1755 sym
= intern (namestring
);
1756 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1759 /* Similar but define a variable whose value is T if address contains 1,
1760 NIL if address contains 0 */
1763 defvar_bool (namestring
, address
, doc
)
1769 sym
= intern (namestring
);
1770 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1773 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1776 defvar_lisp (namestring
, address
, doc
)
1778 Lisp_Object
*address
;
1782 sym
= intern (namestring
);
1783 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1784 staticpro (address
);
1787 /* Similar but don't request gc-marking of the C variable.
1788 Used when that variable will be gc-marked for some other reason,
1789 since marking the same slot twice can cause trouble with strings. */
1792 defvar_lisp_nopro (namestring
, address
, doc
)
1794 Lisp_Object
*address
;
1798 sym
= intern (namestring
);
1799 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1804 /* Similar but define a variable whose value is the Lisp Object stored in
1805 the current buffer. address is the address of the slot in the buffer that is current now. */
1808 defvar_per_buffer (namestring
, address
, type
, doc
)
1810 Lisp_Object
*address
;
1816 extern struct buffer buffer_local_symbols
;
1818 sym
= intern (namestring
);
1819 offset
= (char *)address
- (char *)current_buffer
;
1821 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1822 (Lisp_Object
*) offset
);
1823 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1824 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1825 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1826 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1827 slot of buffer_local_flags */
1831 #endif /* standalone */
1837 /* Compute the default load-path. */
1839 normal
= PATH_LOADSEARCH
;
1840 Vload_path
= decode_env_path (0, normal
);
1842 if (NILP (Vpurify_flag
))
1843 normal
= PATH_LOADSEARCH
;
1845 normal
= PATH_DUMPLOADSEARCH
;
1847 /* In a dumped Emacs, we normally have to reset the value of
1848 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1849 uses ../lisp, instead of the path of the installed elisp
1850 libraries. However, if it appears that Vload_path was changed
1851 from the default before dumping, don't override that value. */
1854 Lisp_Object dump_path
;
1856 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1857 if (! NILP (Fequal (dump_path
, Vload_path
)))
1859 Vload_path
= decode_env_path (0, normal
);
1860 if (!NILP (Vinstallation_directory
))
1862 /* Add to the path the lisp subdir of the
1863 installation dir. */
1865 tem
= Fexpand_file_name (build_string ("lisp"),
1866 Vinstallation_directory
);
1867 if (NILP (Fmember (tem
, Vload_path
)))
1868 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1873 Vload_path
= decode_env_path (0, normal
);
1876 /* Warn if dirs in the *standard* path don't exist. */
1878 Lisp_Object path_tail
;
1880 for (path_tail
= Vload_path
;
1882 path_tail
= XCONS (path_tail
)->cdr
)
1884 Lisp_Object dirfile
;
1885 dirfile
= Fcar (path_tail
);
1886 if (XTYPE (dirfile
) == Lisp_String
)
1888 dirfile
= Fdirectory_file_name (dirfile
);
1889 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1890 fprintf (stderr
, "Warning: lisp library (%s) does not exist.\n",
1891 XSTRING (Fcar (path_tail
))->data
);
1896 /* If the EMACSLOADPATH environment variable is set, use its value.
1897 This doesn't apply if we're dumping. */
1898 if (NILP (Vpurify_flag
)
1899 && egetenv ("EMACSLOADPATH"))
1900 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1904 load_in_progress
= 0;
1906 load_descriptor_list
= Qnil
;
1913 defsubr (&Sread_from_string
);
1915 defsubr (&Sintern_soft
);
1917 defsubr (&Seval_buffer
);
1918 defsubr (&Seval_region
);
1919 defsubr (&Sread_char
);
1920 defsubr (&Sread_char_exclusive
);
1921 defsubr (&Sread_event
);
1922 defsubr (&Sget_file_char
);
1923 defsubr (&Smapatoms
);
1925 DEFVAR_LISP ("obarray", &Vobarray
,
1926 "Symbol table for use by `intern' and `read'.\n\
1927 It is a vector whose length ought to be prime for best results.\n\
1928 The vector's contents don't make sense if examined from Lisp programs;\n\
1929 to find all the symbols in an obarray, use `mapatoms'.");
1931 DEFVAR_LISP ("values", &Vvalues
,
1932 "List of values of all expressions which were read, evaluated and printed.\n\
1933 Order is reverse chronological.");
1935 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1936 "Stream for read to get input from.\n\
1937 See documentation of `read' for possible values.");
1938 Vstandard_input
= Qt
;
1940 DEFVAR_LISP ("load-path", &Vload_path
,
1941 "*List of directories to search for files to load.\n\
1942 Each element is a string (directory name) or nil (try default directory).\n\
1943 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1944 otherwise to default specified by file `paths.h' when Emacs was built.");
1946 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1947 "Non-nil iff inside of `load'.");
1949 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1950 "An alist of expressions to be evalled when particular files are loaded.\n\
1951 Each element looks like (FILENAME FORMS...).\n\
1952 When `load' is run and the file-name argument is FILENAME,\n\
1953 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1954 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1955 with no directory specified, since that is how `load' is normally called.\n\
1956 An error in FORMS does not undo the load,\n\
1957 but does prevent execution of the rest of the FORMS.");
1958 Vafter_load_alist
= Qnil
;
1960 DEFVAR_LISP ("load-history", &Vload_history
,
1961 "Alist mapping source file names to symbols and features.\n\
1962 Each alist element is a list that starts with a file name,\n\
1963 except for one element (optional) that starts with nil and describes\n\
1964 definitions evaluated from buffers not visiting files.\n\
1965 The remaining elements of each list are symbols defined as functions\n\
1966 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1967 Vload_history
= Qnil
;
1969 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1970 "Used for internal purposes by `load'.");
1971 Vcurrent_load_list
= Qnil
;
1973 load_descriptor_list
= Qnil
;
1974 staticpro (&load_descriptor_list
);
1976 Qcurrent_load_list
= intern ("current-load-list");
1977 staticpro (&Qcurrent_load_list
);
1979 Qstandard_input
= intern ("standard-input");
1980 staticpro (&Qstandard_input
);
1982 Qread_char
= intern ("read-char");
1983 staticpro (&Qread_char
);
1985 Qget_file_char
= intern ("get-file-char");
1986 staticpro (&Qget_file_char
);
1988 Qascii_character
= intern ("ascii-character");
1989 staticpro (&Qascii_character
);
1991 Qload
= intern ("load");