1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989,
3 1993, 1994 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. */
24 #include <sys/types.h>
36 #include "termhooks.h"
40 #include <sys/inode.h>
47 #ifdef LISP_FLOAT_TYPE
54 /* These are redefined (correctly, but differently) in values.h. */
61 #endif /* LISP_FLOAT_TYPE */
69 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
70 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
71 Lisp_Object Qascii_character
, Qload
;
73 extern Lisp_Object Qevent_symbol_element_mask
;
75 /* non-zero if inside `load' */
78 /* Search path for files to be loaded. */
79 Lisp_Object Vload_path
;
81 /* This is the user-visible association list that maps features to
82 lists of defs in their load files. */
83 Lisp_Object Vload_history
;
85 /* This is useud to build the load history. */
86 Lisp_Object Vcurrent_load_list
;
88 /* List of descriptors now open for Fload. */
89 static Lisp_Object load_descriptor_list
;
91 /* File for get_file_char to read from. Use by load */
92 static FILE *instream
;
94 /* When nonzero, read conses in pure space */
97 /* For use within read-from-string (this reader is non-reentrant!!) */
98 static int read_from_string_index
;
99 static int read_from_string_limit
;
101 /* Handle unreading and rereading of characters.
102 Write READCHAR to read a character,
103 UNREAD(c) to unread c to be read again. */
105 #define READCHAR readchar (readcharfun)
106 #define UNREAD(c) unreadchar (readcharfun, c)
109 readchar (readcharfun
)
110 Lisp_Object readcharfun
;
113 register struct buffer
*inbuffer
;
114 register int c
, mpos
;
116 if (BUFFERP (readcharfun
))
118 inbuffer
= XBUFFER (readcharfun
);
120 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
122 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
123 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
127 if (MARKERP (readcharfun
))
129 inbuffer
= XMARKER (readcharfun
)->buffer
;
131 mpos
= marker_position (readcharfun
);
133 if (mpos
> BUF_ZV (inbuffer
) - 1)
135 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
136 if (mpos
!= BUF_GPT (inbuffer
))
137 XMARKER (readcharfun
)->bufpos
++;
139 Fset_marker (readcharfun
, make_number (mpos
+ 1),
140 Fmarker_buffer (readcharfun
));
143 if (EQ (readcharfun
, Qget_file_char
))
147 /* Interrupted reads have been observed while reading over the network */
148 while (c
== EOF
&& ferror (instream
) && errno
== EINTR
)
157 if (STRINGP (readcharfun
))
160 /* This used to be return of a conditional expression,
161 but that truncated -1 to a char on VMS. */
162 if (read_from_string_index
< read_from_string_limit
)
163 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
169 tem
= call0 (readcharfun
);
176 /* Unread the character C in the way appropriate for the stream READCHARFUN.
177 If the stream is a user function, call it with the char as argument. */
180 unreadchar (readcharfun
, c
)
181 Lisp_Object readcharfun
;
185 /* Don't back up the pointer if we're unreading the end-of-input mark,
186 since readchar didn't advance it when we read it. */
188 else if (BUFFERP (readcharfun
))
190 if (XBUFFER (readcharfun
) == current_buffer
)
193 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
195 else if (MARKERP (readcharfun
))
196 XMARKER (readcharfun
)->bufpos
--;
197 else if (STRINGP (readcharfun
))
198 read_from_string_index
--;
199 else if (EQ (readcharfun
, Qget_file_char
))
200 ungetc (c
, instream
);
202 call1 (readcharfun
, make_number (c
));
205 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
207 /* get a character from the tty */
209 extern Lisp_Object
read_char ();
211 /* Read input events until we get one that's acceptable for our purposes.
213 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
214 until we get a character we like, and then stuffed into
217 If ASCII_REQUIRED is non-zero, we check function key events to see
218 if the unmodified version of the symbol has a Qascii_character
219 property, and use that character, if present.
221 If ERROR_NONASCII is non-zero, we signal an error if the input we
222 get isn't an ASCII character with modifiers. If it's zero but
223 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
226 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
227 int no_switch_frame
, ascii_required
, error_nonascii
;
230 return make_number (getchar ());
232 register Lisp_Object val
, delayed_switch_frame
;
234 delayed_switch_frame
= Qnil
;
236 /* Read until we get an acceptable event. */
238 val
= read_char (0, 0, 0, Qnil
, 0);
243 /* switch-frame events are put off until after the next ASCII
244 character. This is better than signalling an error just because
245 the last characters were typed to a separate minibuffer frame,
246 for example. Eventually, some code which can deal with
247 switch-frame events will read it and process it. */
249 && EVENT_HAS_PARAMETERS (val
)
250 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
252 delayed_switch_frame
= val
;
258 /* Convert certain symbols to their ASCII equivalents. */
261 Lisp_Object tem
, tem1
, tem2
;
262 tem
= Fget (val
, Qevent_symbol_element_mask
);
265 tem1
= Fget (Fcar (tem
), Qascii_character
);
266 /* Merge this symbol's modifier bits
267 with the ASCII equivalent of its basic code. */
269 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
273 /* If we don't have a character now, deal with it appropriately. */
278 Vunread_command_events
= Fcons (val
, Qnil
);
279 error ("Non-character input-event");
286 if (! NILP (delayed_switch_frame
))
287 unread_switch_frame
= delayed_switch_frame
;
293 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
294 "Read a character from the command input (keyboard or macro).\n\
295 It is returned as a number.\n\
296 If the user generates an event which is not a character (i.e. a mouse\n\
297 click or function key event), `read-char' signals an error. As an\n\
298 exception, switch-frame events are put off until non-ASCII events can\n\
300 If you want to read non-character events, or ignore them, call\n\
301 `read-event' or `read-char-exclusive' instead.")
304 return read_filtered_event (1, 1, 1);
307 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
308 "Read an event object from the input stream.")
311 return read_filtered_event (0, 0, 0);
314 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
315 "Read a character from the command input (keyboard or macro).\n\
316 It is returned as a number. Non character events are ignored.")
319 return read_filtered_event (1, 1, 0);
322 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
323 "Don't use this yourself.")
326 register Lisp_Object val
;
327 XSETINT (val
, getc (instream
));
331 static void readevalloop ();
332 static Lisp_Object
load_unwind ();
333 static Lisp_Object
load_descriptor_unwind ();
335 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
336 "Execute a file of Lisp code named FILE.\n\
337 First try FILE with `.elc' appended, then try with `.el',\n\
338 then try FILE unmodified.\n\
339 This function searches the directories in `load-path'.\n\
340 If optional second arg NOERROR is non-nil,\n\
341 report no error if FILE doesn't exist.\n\
342 Print messages at start and end of loading unless\n\
343 optional third arg NOMESSAGE is non-nil.\n\
344 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
345 suffixes `.elc' or `.el' to the specified name FILE.\n\
346 Return t if file exists.")
347 (str
, noerror
, nomessage
, nosuffix
)
348 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
350 register FILE *stream
;
351 register int fd
= -1;
352 register Lisp_Object lispstream
;
354 int count
= specpdl_ptr
- specpdl
;
358 /* 1 means inhibit the message at the beginning. */
362 char *dosmode
= "rt";
365 CHECK_STRING (str
, 0);
366 str
= Fsubstitute_in_file_name (str
);
368 /* If file name is magic, call the handler. */
369 handler
= Ffind_file_name_handler (str
, Qload
);
371 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
373 /* Avoid weird lossage with null string as arg,
374 since it would try to load a directory as a Lisp file */
375 if (XSTRING (str
)->size
> 0)
378 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
387 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
393 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
402 stat ((char *)XSTRING (found
)->data
, &s1
);
403 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
404 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
405 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
407 message ("Source file `%s' newer than byte-compiled file",
408 XSTRING (found
)->data
);
409 /* Don't immediately overwrite this message. */
413 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
418 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
420 stream
= fdopen (fd
, "r");
425 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
428 if (NILP (nomessage
) && !nomessage1
)
429 message ("Loading %s...", XSTRING (str
)->data
);
432 /* We may not be able to store STREAM itself as a Lisp_Object pointer
433 since that is guaranteed to work only for data that has been malloc'd.
434 So malloc a full-size pointer, and record the address of that pointer. */
435 ptr
= (FILE **) xmalloc (sizeof (FILE *));
437 XSETINTERNAL_STREAM (lispstream
, (EMACS_INT
) ptr
);
438 record_unwind_protect (load_unwind
, lispstream
);
439 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
441 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
443 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
444 unbind_to (count
, Qnil
);
446 /* Run any load-hooks for this file. */
447 temp
= Fassoc (str
, Vafter_load_alist
);
449 Fprogn (Fcdr (temp
));
452 if (!noninteractive
&& NILP (nomessage
))
453 message ("Loading %s...done", XSTRING (str
)->data
);
458 load_unwind (stream
) /* used as unwind-protect function in load */
461 fclose (*(FILE **) XSTRING (stream
));
462 xfree (XPNTR (stream
));
463 if (--load_in_progress
< 0) load_in_progress
= 0;
468 load_descriptor_unwind (oldlist
)
471 load_descriptor_list
= oldlist
;
474 /* Close all descriptors in use for Floads.
475 This is used when starting a subprocess. */
481 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
482 close (XFASTINT (XCONS (tail
)->car
));
486 complete_filename_p (pathname
)
487 Lisp_Object pathname
;
489 register unsigned char *s
= XSTRING (pathname
)->data
;
497 #ifdef MSDOS /* MW, May 1993 */
498 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
503 /* Search for a file whose name is STR, looking in directories
504 in the Lisp list PATH, and trying suffixes from SUFFIX.
505 SUFFIX is a string containing possible suffixes separated by colons.
506 On success, returns a file descriptor. On failure, returns -1.
508 EXEC_ONLY nonzero means don't open the files,
509 just look for one that is executable. In this case,
510 returns 1 on success.
512 If STOREPTR is nonzero, it points to a slot where the name of
513 the file actually found should be stored as a Lisp string.
514 Nil is stored there on failure. */
517 openp (path
, str
, suffix
, storeptr
, exec_only
)
518 Lisp_Object path
, str
;
520 Lisp_Object
*storeptr
;
526 register char *fn
= buf
;
529 register Lisp_Object filename
;
537 if (complete_filename_p (str
))
540 for (; !NILP (path
); path
= Fcdr (path
))
544 filename
= Fexpand_file_name (str
, Fcar (path
));
545 if (!complete_filename_p (filename
))
546 /* If there are non-absolute elts in PATH (eg ".") */
547 /* Of course, this could conceivably lose if luser sets
548 default-directory to be something non-absolute... */
550 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
551 if (!complete_filename_p (filename
))
552 /* Give up on this path element! */
556 /* Calculate maximum size of any filename made from
557 this path element/specified file name and any possible suffix. */
558 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
559 if (fn_size
< want_size
)
560 fn
= (char *) alloca (fn_size
= 100 + want_size
);
564 /* Loop over suffixes. */
567 char *esuffix
= (char *) index (nsuffix
, ':');
568 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
570 /* Concatenate path element/specified name with the suffix. */
571 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
572 fn
[XSTRING (filename
)->size
] = 0;
573 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
574 strncat (fn
, nsuffix
, lsuffix
);
576 /* Ignore file if it's a directory. */
577 if (stat (fn
, &st
) >= 0
578 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
580 /* Check that we can access or open it. */
582 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
584 fd
= open (fn
, O_RDONLY
, 0);
588 /* We succeeded; return this descriptor and filename. */
590 *storeptr
= build_string (fn
);
596 /* Advance to next suffix. */
599 nsuffix
+= lsuffix
+ 1;
610 /* Merge the list we've accumulated of globals from the current input source
611 into the load_history variable. The details depend on whether
612 the source has an associated file name or not. */
615 build_load_history (stream
, source
)
619 register Lisp_Object tail
, prev
, newelt
;
620 register Lisp_Object tem
, tem2
;
621 register int foundit
, loading
;
623 /* Don't bother recording anything for preloaded files. */
624 if (!NILP (Vpurify_flag
))
627 loading
= stream
|| !NARROWED
;
629 tail
= Vload_history
;
636 /* Find the feature's previous assoc list... */
637 if (!NILP (Fequal (source
, Fcar (tem
))))
641 /* If we're loading, remove it. */
645 Vload_history
= Fcdr (tail
);
647 Fsetcdr (prev
, Fcdr (tail
));
650 /* Otherwise, cons on new symbols that are not already members. */
653 tem2
= Vcurrent_load_list
;
657 newelt
= Fcar (tem2
);
659 if (NILP (Fmemq (newelt
, tem
)))
660 Fsetcar (tail
, Fcons (Fcar (tem
),
661 Fcons (newelt
, Fcdr (tem
))));
674 /* If we're loading, cons the new assoc onto the front of load-history,
675 the most-recently-loaded position. Also do this if we didn't find
676 an existing member for the current source. */
677 if (loading
|| !foundit
)
678 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
683 unreadpure () /* Used as unwind-protect function in readevalloop */
690 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
691 Lisp_Object readcharfun
;
693 Lisp_Object sourcename
;
694 Lisp_Object (*evalfun
) ();
698 register Lisp_Object val
;
699 int count
= specpdl_ptr
- specpdl
;
701 struct buffer
*b
= 0;
703 if (BUFFERP (readcharfun
))
704 b
= XBUFFER (readcharfun
);
705 else if (MARKERP (readcharfun
))
706 b
= XMARKER (readcharfun
)->buffer
;
708 specbind (Qstandard_input
, readcharfun
);
709 specbind (Qcurrent_load_list
, Qnil
);
713 LOADHIST_ATTACH (sourcename
);
717 if (b
!= 0 && NILP (b
->name
))
718 error ("Reading from killed buffer");
724 while ((c
= READCHAR
) != '\n' && c
!= -1);
728 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
730 if (!NILP (Vpurify_flag
) && c
== '(')
732 int count1
= specpdl_ptr
- specpdl
;
733 record_unwind_protect (unreadpure
, Qnil
);
734 val
= read_list (-1, readcharfun
);
735 unbind_to (count1
, Qnil
);
740 val
= read0 (readcharfun
);
743 val
= (*evalfun
) (val
);
746 Vvalues
= Fcons (val
, Vvalues
);
747 if (EQ (Vstandard_output
, Qt
))
754 build_load_history (stream
, sourcename
);
757 unbind_to (count
, Qnil
);
762 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
763 "Execute the current buffer as Lisp code.\n\
764 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
765 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
766 PRINTFLAG controls printing of output:\n\
767 nil means discard it; anything else is stream for print.\n\
769 If there is no error, point does not move. If there is an error,\n\
770 point remains at the end of the last character read from the buffer.")
772 Lisp_Object bufname
, printflag
;
774 int count
= specpdl_ptr
- specpdl
;
775 Lisp_Object tem
, buf
;
778 buf
= Fcurrent_buffer ();
780 buf
= Fget_buffer (bufname
);
782 error ("No such buffer.");
784 if (NILP (printflag
))
788 specbind (Qstandard_output
, tem
);
789 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
790 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
791 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
792 unbind_to (count
, Qnil
);
798 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
799 "Execute the current buffer as Lisp code.\n\
800 Programs can pass argument PRINTFLAG which controls printing of output:\n\
801 nil means discard it; anything else is stream for print.\n\
803 If there is no error, point does not move. If there is an error,\n\
804 point remains at the end of the last character read from the buffer.")
806 Lisp_Object printflag
;
808 int count
= specpdl_ptr
- specpdl
;
809 Lisp_Object tem
, cbuf
;
811 cbuf
= Fcurrent_buffer ()
813 if (NILP (printflag
))
817 specbind (Qstandard_output
, tem
);
818 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
820 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
821 return unbind_to (count
, Qnil
);
825 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
826 "Execute the region as Lisp code.\n\
827 When called from programs, expects two arguments,\n\
828 giving starting and ending indices in the current buffer\n\
829 of the text to be executed.\n\
830 Programs can pass third argument PRINTFLAG which controls output:\n\
831 nil means discard it; anything else is stream for printing it.\n\
833 If there is no error, point does not move. If there is an error,\n\
834 point remains at the end of the last character read from the buffer.")
836 Lisp_Object b
, e
, printflag
;
838 int count
= specpdl_ptr
- specpdl
;
839 Lisp_Object tem
, cbuf
;
841 cbuf
= Fcurrent_buffer ();
843 if (NILP (printflag
))
847 specbind (Qstandard_output
, tem
);
849 if (NILP (printflag
))
850 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
851 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
853 /* This both uses b and checks its type. */
855 Fnarrow_to_region (make_number (BEGV
), e
);
856 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
858 return unbind_to (count
, Qnil
);
861 #endif /* standalone */
863 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
864 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
865 If STREAM is nil, use the value of `standard-input' (which see).\n\
866 STREAM or the value of `standard-input' may be:\n\
867 a buffer (read from point and advance it)\n\
868 a marker (read from where it points and advance it)\n\
869 a function (call it with no arguments for each character,\n\
870 call it with a char as argument to push a char back)\n\
871 a string (takes text from string, starting at the beginning)\n\
872 t (read text line using minibuffer and use it).")
874 Lisp_Object readcharfun
;
876 extern Lisp_Object
Fread_minibuffer ();
878 if (NILP (readcharfun
))
879 readcharfun
= Vstandard_input
;
880 if (EQ (readcharfun
, Qt
))
881 readcharfun
= Qread_char
;
884 if (EQ (readcharfun
, Qread_char
))
885 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
888 if (STRINGP (readcharfun
))
889 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
891 return read0 (readcharfun
);
894 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
895 "Read one Lisp expression which is represented as text by STRING.\n\
896 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
897 START and END optionally delimit a substring of STRING from which to read;\n\
898 they default to 0 and (length STRING) respectively.")
900 Lisp_Object string
, start
, end
;
902 int startval
, endval
;
905 CHECK_STRING (string
,0);
908 endval
= XSTRING (string
)->size
;
910 { CHECK_NUMBER (end
,2);
912 if (endval
< 0 || endval
> XSTRING (string
)->size
)
913 args_out_of_range (string
, end
);
919 { CHECK_NUMBER (start
,1);
920 startval
= XINT (start
);
921 if (startval
< 0 || startval
> endval
)
922 args_out_of_range (string
, start
);
925 read_from_string_index
= startval
;
926 read_from_string_limit
= endval
;
928 tem
= read0 (string
);
929 return Fcons (tem
, make_number (read_from_string_index
));
932 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
936 Lisp_Object readcharfun
;
938 register Lisp_Object val
;
941 val
= read1 (readcharfun
);
945 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
951 static int read_buffer_size
;
952 static char *read_buffer
;
955 read_escape (readcharfun
)
956 Lisp_Object readcharfun
;
958 register int c
= READCHAR
;
985 error ("Invalid escape character syntax");
988 c
= read_escape (readcharfun
);
989 return c
| meta_modifier
;
994 error ("Invalid escape character syntax");
997 c
= read_escape (readcharfun
);
998 return c
| shift_modifier
;
1003 error ("Invalid escape character syntax");
1006 c
= read_escape (readcharfun
);
1007 return c
| hyper_modifier
;
1012 error ("Invalid escape character syntax");
1015 c
= read_escape (readcharfun
);
1016 return c
| alt_modifier
;
1021 error ("Invalid escape character syntax");
1024 c
= read_escape (readcharfun
);
1025 return c
| super_modifier
;
1030 error ("Invalid escape character syntax");
1034 c
= read_escape (readcharfun
);
1035 if ((c
& 0177) == '?')
1037 /* ASCII control chars are made from letters (both cases),
1038 as well as the non-letters within 0100...0137. */
1039 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1040 return (c
& (037 | ~0177));
1041 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1042 return (c
& (037 | ~0177));
1044 return c
| ctrl_modifier
;
1054 /* An octal escape, as in ANSI C. */
1056 register int i
= c
- '0';
1057 register int count
= 0;
1060 if ((c
= READCHAR
) >= '0' && c
<= '7')
1075 /* A hex escape, as in ANSI C. */
1081 if (c
>= '0' && c
<= '9')
1086 else if ((c
>= 'a' && c
<= 'f')
1087 || (c
>= 'A' && c
<= 'F'))
1090 if (c
>= 'a' && c
<= 'f')
1111 register Lisp_Object readcharfun
;
1118 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1123 return read_list (0, readcharfun
);
1126 return read_vector (readcharfun
);
1131 register Lisp_Object val
;
1132 XSETINTERNAL (val
, c
);
1140 /* Accept compiled functions at read-time so that we don't have to
1141 build them using function calls. */
1143 tmp
= read_vector (readcharfun
);
1144 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1145 XVECTOR (tmp
)->contents
);
1147 #ifdef USE_TEXT_PROPERTIES
1151 struct gcpro gcpro1
;
1153 /* Read the string itself. */
1154 tmp
= read1 (readcharfun
);
1156 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1158 /* Read the intervals and their properties. */
1161 Lisp_Object beg
, end
, plist
;
1163 beg
= read1 (readcharfun
);
1164 if (INTERNALP (beg
))
1166 if (XINT (beg
) == ')')
1168 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1170 end
= read1 (readcharfun
);
1171 if (INTERNALP (end
))
1172 Fsignal (Qinvalid_read_syntax
,
1173 Fcons (make_string ("invalid string property list", 28), Qnil
));
1175 plist
= read1 (readcharfun
);
1176 if (INTERNALP (plist
))
1177 Fsignal (Qinvalid_read_syntax
,
1178 Fcons (make_string ("invalid string property list", 28), Qnil
));
1179 Fset_text_properties (beg
, end
, plist
, tmp
);
1186 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1189 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1194 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1199 register Lisp_Object val
;
1202 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1205 XSETINT (val
, read_escape (readcharfun
));
1214 register char *p
= read_buffer
;
1215 register char *end
= read_buffer
+ read_buffer_size
;
1219 while ((c
= READCHAR
) >= 0
1224 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1225 p
+= new - read_buffer
;
1226 read_buffer
+= new - read_buffer
;
1227 end
= read_buffer
+ read_buffer_size
;
1230 c
= read_escape (readcharfun
);
1231 /* c is -1 if \ newline has just been seen */
1234 if (p
== read_buffer
)
1239 /* Allow `\C- ' and `\C-?'. */
1240 if (c
== (CHAR_CTL
| ' '))
1242 else if (c
== (CHAR_CTL
| '?'))
1246 /* Move the meta bit to the right place for a string. */
1247 c
= (c
& ~CHAR_META
) | 0x80;
1249 error ("Invalid modifier in string");
1253 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1255 /* If purifying, and string starts with \ newline,
1256 return zero instead. This is for doc strings
1257 that we are really going to find in etc/DOC.nn.nn */
1258 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1259 return make_number (0);
1262 return make_pure_string (read_buffer
, p
- read_buffer
);
1264 return make_string (read_buffer
, p
- read_buffer
);
1269 #ifdef LISP_FLOAT_TYPE
1270 /* If a period is followed by a number, then we should read it
1271 as a floating point number. Otherwise, it denotes a dotted
1273 int next_char
= READCHAR
;
1276 if (! isdigit (next_char
))
1279 register Lisp_Object val
;
1280 XSETINTERNAL (val
, c
);
1284 /* Otherwise, we fall through! Note that the atom-reading loop
1285 below will now loop at least once, assuring that we will not
1286 try to UNREAD two characters in a row. */
1289 if (c
<= 040) goto retry
;
1291 register char *p
= read_buffer
;
1295 register char *end
= read_buffer
+ read_buffer_size
;
1298 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1299 || c
== '(' || c
== ')'
1300 #ifndef LISP_FLOAT_TYPE
1301 /* If we have floating-point support, then we need
1302 to allow <digits><dot><digits>. */
1304 #endif /* not LISP_FLOAT_TYPE */
1305 || c
== '[' || c
== ']' || c
== '#'
1310 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1311 p
+= new - read_buffer
;
1312 read_buffer
+= new - read_buffer
;
1313 end
= read_buffer
+ read_buffer_size
;
1326 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1327 p
+= new - read_buffer
;
1328 read_buffer
+= new - read_buffer
;
1329 /* end = read_buffer + read_buffer_size; */
1339 register Lisp_Object val
;
1341 if (*p1
== '+' || *p1
== '-') p1
++;
1342 /* Is it an integer? */
1345 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1346 #ifdef LISP_FLOAT_TYPE
1347 /* Integers can have trailing decimal points. */
1348 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1351 /* It is an integer. */
1353 #ifdef LISP_FLOAT_TYPE
1357 XSETINT (val
, atoi (read_buffer
));
1361 #ifdef LISP_FLOAT_TYPE
1362 if (isfloat_string (read_buffer
))
1363 return make_float (atof (read_buffer
));
1367 return intern (read_buffer
);
1372 #ifdef LISP_FLOAT_TYPE
1387 if (*cp
== '+' || *cp
== '-')
1393 while (isdigit (*cp
))
1404 while (isdigit (*cp
))
1412 if ((*cp
== '+') || (*cp
== '-'))
1418 while (isdigit (*cp
))
1422 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1423 || state
== (DOT_CHAR
|TRAIL_INT
)
1424 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1425 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1426 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1428 #endif /* LISP_FLOAT_TYPE */
1431 read_vector (readcharfun
)
1432 Lisp_Object readcharfun
;
1436 register Lisp_Object
*ptr
;
1437 register Lisp_Object tem
, vector
;
1438 register struct Lisp_Cons
*otem
;
1441 tem
= read_list (1, readcharfun
);
1442 len
= Flength (tem
);
1443 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1446 size
= XVECTOR (vector
)->size
;
1447 ptr
= XVECTOR (vector
)->contents
;
1448 for (i
= 0; i
< size
; i
++)
1450 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1458 /* flag = 1 means check for ] to terminate rather than ) and .
1459 flag = -1 means check for starting with defun
1460 and make structure pure. */
1463 read_list (flag
, readcharfun
)
1465 register Lisp_Object readcharfun
;
1467 /* -1 means check next element for defun,
1468 0 means don't check,
1469 1 means already checked and found defun. */
1470 int defunflag
= flag
< 0 ? -1 : 0;
1471 Lisp_Object val
, tail
;
1472 register Lisp_Object elt
, tem
;
1473 struct gcpro gcpro1
, gcpro2
;
1481 elt
= read1 (readcharfun
);
1483 if (INTERNALP (elt
))
1487 if (XINT (elt
) == ']')
1489 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1491 if (XINT (elt
) == ')')
1493 if (XINT (elt
) == '.')
1497 XCONS (tail
)->cdr
= read0 (readcharfun
);
1499 val
= read0 (readcharfun
);
1500 elt
= read1 (readcharfun
);
1502 if (INTERNALP (elt
) && XINT (elt
) == ')')
1504 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1506 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1508 tem
= (read_pure
&& flag
<= 0
1509 ? pure_cons (elt
, Qnil
)
1510 : Fcons (elt
, Qnil
));
1512 XCONS (tail
)->cdr
= tem
;
1517 defunflag
= EQ (elt
, Qdefun
);
1518 else if (defunflag
> 0)
1523 Lisp_Object Vobarray
;
1524 Lisp_Object initial_obarray
;
1527 check_obarray (obarray
)
1528 Lisp_Object obarray
;
1530 while (!VECTORP (obarray
) || XVECTOR (obarray
)->size
== 0)
1532 /* If Vobarray is now invalid, force it to be valid. */
1533 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1535 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1540 static int hash_string ();
1541 Lisp_Object
oblookup ();
1548 int len
= strlen (str
);
1549 Lisp_Object obarray
;
1552 if (!VECTORP (obarray
) || XVECTOR (obarray
)->size
== 0)
1553 obarray
= check_obarray (obarray
);
1554 tem
= oblookup (obarray
, str
, len
);
1557 return Fintern ((!NILP (Vpurify_flag
)
1558 ? make_pure_string (str
, len
)
1559 : make_string (str
, len
)),
1563 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1564 "Return the canonical symbol whose name is STRING.\n\
1565 If there is none, one is created by this function and returned.\n\
1566 A second optional argument specifies the obarray to use;\n\
1567 it defaults to the value of `obarray'.")
1569 Lisp_Object str
, obarray
;
1571 register Lisp_Object tem
, sym
, *ptr
;
1573 if (NILP (obarray
)) obarray
= Vobarray
;
1574 obarray
= check_obarray (obarray
);
1576 CHECK_STRING (str
, 0);
1578 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1579 if (!INTEGERP (tem
))
1582 if (!NILP (Vpurify_flag
))
1583 str
= Fpurecopy (str
);
1584 sym
= Fmake_symbol (str
);
1586 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1588 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1590 XSYMBOL (sym
)->next
= 0;
1595 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1596 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1597 A second optional argument specifies the obarray to use;\n\
1598 it defaults to the value of `obarray'.")
1600 Lisp_Object str
, obarray
;
1602 register Lisp_Object tem
;
1604 if (NILP (obarray
)) obarray
= Vobarray
;
1605 obarray
= check_obarray (obarray
);
1607 CHECK_STRING (str
, 0);
1609 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1610 if (!INTEGERP (tem
))
1616 oblookup (obarray
, ptr
, size
)
1617 Lisp_Object obarray
;
1623 register Lisp_Object tail
;
1624 Lisp_Object bucket
, tem
;
1626 if (!VECTORP (obarray
)
1627 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1629 obarray
= check_obarray (obarray
);
1630 obsize
= XVECTOR (obarray
)->size
;
1632 /* Combining next two lines breaks VMS C 2.3. */
1633 hash
= hash_string (ptr
, size
);
1635 bucket
= XVECTOR (obarray
)->contents
[hash
];
1636 if (XFASTINT (bucket
) == 0)
1638 else if (!SYMBOLP (bucket
))
1639 error ("Bad data in guts of obarray"); /* Like CADR error message */
1640 else for (tail
= bucket
; ; XSETSYMBOL (tail
, XSYMBOL (tail
)->next
))
1642 if (XSYMBOL (tail
)->name
->size
== size
&&
1643 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1645 else if (XSYMBOL (tail
)->next
== 0)
1648 XSETINT (tem
, hash
);
1653 hash_string (ptr
, len
)
1657 register unsigned char *p
= ptr
;
1658 register unsigned char *end
= p
+ len
;
1659 register unsigned char c
;
1660 register int hash
= 0;
1665 if (c
>= 0140) c
-= 40;
1666 hash
= ((hash
<<3) + (hash
>>28) + c
);
1668 return hash
& 07777777777;
1672 map_obarray (obarray
, fn
, arg
)
1673 Lisp_Object obarray
;
1678 register Lisp_Object tail
;
1679 CHECK_VECTOR (obarray
, 1);
1680 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1682 tail
= XVECTOR (obarray
)->contents
[i
];
1683 if (XFASTINT (tail
) != 0)
1687 if (XSYMBOL (tail
)->next
== 0)
1689 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1694 mapatoms_1 (sym
, function
)
1695 Lisp_Object sym
, function
;
1697 call1 (function
, sym
);
1700 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1701 "Call FUNCTION on every symbol in OBARRAY.\n\
1702 OBARRAY defaults to the value of `obarray'.")
1704 Lisp_Object function
, obarray
;
1708 if (NILP (obarray
)) obarray
= Vobarray
;
1709 obarray
= check_obarray (obarray
);
1711 map_obarray (obarray
, mapatoms_1
, function
);
1715 #define OBARRAY_SIZE 1511
1720 Lisp_Object oblength
;
1724 XFASTINT (oblength
) = OBARRAY_SIZE
;
1726 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1727 Vobarray
= Fmake_vector (oblength
, make_number (0));
1728 initial_obarray
= Vobarray
;
1729 staticpro (&initial_obarray
);
1730 /* Intern nil in the obarray */
1731 /* These locals are to kludge around a pyramid compiler bug. */
1732 hash
= hash_string ("nil", 3);
1733 /* Separate statement here to avoid VAXC bug. */
1734 hash
%= OBARRAY_SIZE
;
1735 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1738 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1739 XSYMBOL (Qnil
)->function
= Qunbound
;
1740 XSYMBOL (Qunbound
)->value
= Qunbound
;
1741 XSYMBOL (Qunbound
)->function
= Qunbound
;
1744 XSYMBOL (Qnil
)->value
= Qnil
;
1745 XSYMBOL (Qnil
)->plist
= Qnil
;
1746 XSYMBOL (Qt
)->value
= Qt
;
1748 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1751 Qvariable_documentation
= intern ("variable-documentation");
1753 read_buffer_size
= 100;
1754 read_buffer
= (char *) malloc (read_buffer_size
);
1759 struct Lisp_Subr
*sname
;
1762 sym
= intern (sname
->symbol_name
);
1763 XSETSUBR (XSYMBOL (sym
)->function
, sname
);
1766 #ifdef NOTDEF /* use fset in subr.el now */
1768 defalias (sname
, string
)
1769 struct Lisp_Subr
*sname
;
1773 sym
= intern (string
);
1774 XSETSUBR (XSYMBOL (sym
)->function
, sname
);
1778 /* Define an "integer variable"; a symbol whose value is forwarded
1779 to a C variable of type int. Sample call: */
1780 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1783 defvar_int (namestring
, address
)
1788 sym
= intern (namestring
);
1789 XSETINTFWD (XSYMBOL (sym
)->value
, address
);
1792 /* Similar but define a variable whose value is T if address contains 1,
1793 NIL if address contains 0 */
1796 defvar_bool (namestring
, address
)
1801 sym
= intern (namestring
);
1802 XSETBOOLFWD (XSYMBOL (sym
)->value
, address
);
1805 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1808 defvar_lisp (namestring
, address
)
1810 Lisp_Object
*address
;
1813 sym
= intern (namestring
);
1814 XSETOBJFWD (XSYMBOL (sym
)->value
, address
);
1815 staticpro (address
);
1818 /* Similar but don't request gc-marking of the C variable.
1819 Used when that variable will be gc-marked for some other reason,
1820 since marking the same slot twice can cause trouble with strings. */
1823 defvar_lisp_nopro (namestring
, address
)
1825 Lisp_Object
*address
;
1828 sym
= intern (namestring
);
1829 XSETOBJFWD (XSYMBOL (sym
)->value
, address
);
1834 /* Similar but define a variable whose value is the Lisp Object stored in
1835 the current buffer. address is the address of the slot in the buffer that is current now. */
1838 defvar_per_buffer (namestring
, address
, type
, doc
)
1840 Lisp_Object
*address
;
1846 extern struct buffer buffer_local_symbols
;
1848 sym
= intern (namestring
);
1849 offset
= (char *)address
- (char *)current_buffer
;
1851 XSETBUFFER_OBJFWD (XSYMBOL (sym
)->value
,
1852 (Lisp_Object
*) offset
);
1853 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1854 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1855 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1856 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1857 slot of buffer_local_flags */
1861 #endif /* standalone */
1867 /* Compute the default load-path. */
1869 normal
= PATH_LOADSEARCH
;
1870 Vload_path
= decode_env_path (0, normal
);
1872 if (NILP (Vpurify_flag
))
1873 normal
= PATH_LOADSEARCH
;
1875 normal
= PATH_DUMPLOADSEARCH
;
1877 /* In a dumped Emacs, we normally have to reset the value of
1878 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1879 uses ../lisp, instead of the path of the installed elisp
1880 libraries. However, if it appears that Vload_path was changed
1881 from the default before dumping, don't override that value. */
1884 Lisp_Object dump_path
;
1886 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1887 if (! NILP (Fequal (dump_path
, Vload_path
)))
1889 Vload_path
= decode_env_path (0, normal
);
1890 if (!NILP (Vinstallation_directory
))
1892 /* Add to the path the lisp subdir of the
1893 installation dir, if it exists. */
1894 Lisp_Object tem
, tem1
;
1895 tem
= Fexpand_file_name (build_string ("lisp"),
1896 Vinstallation_directory
);
1897 tem1
= Ffile_exists_p (tem
);
1900 if (NILP (Fmember (tem
, Vload_path
)))
1901 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1904 /* That dir doesn't exist, so add the build-time
1905 Lisp dirs instead. */
1906 Vload_path
= nconc2 (Vload_path
, dump_path
);
1911 Vload_path
= decode_env_path (0, normal
);
1914 /* Warn if dirs in the *standard* path don't exist. */
1916 Lisp_Object path_tail
;
1918 for (path_tail
= Vload_path
;
1920 path_tail
= XCONS (path_tail
)->cdr
)
1922 Lisp_Object dirfile
;
1923 dirfile
= Fcar (path_tail
);
1924 if (STRINGP (dirfile
))
1926 dirfile
= Fdirectory_file_name (dirfile
);
1927 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1929 "Warning: Lisp directory `%s' does not exist.\n",
1930 XSTRING (Fcar (path_tail
))->data
);
1935 /* If the EMACSLOADPATH environment variable is set, use its value.
1936 This doesn't apply if we're dumping. */
1937 if (NILP (Vpurify_flag
)
1938 && egetenv ("EMACSLOADPATH"))
1939 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1943 load_in_progress
= 0;
1945 load_descriptor_list
= Qnil
;
1952 defsubr (&Sread_from_string
);
1954 defsubr (&Sintern_soft
);
1956 defsubr (&Seval_buffer
);
1957 defsubr (&Seval_region
);
1958 defsubr (&Sread_char
);
1959 defsubr (&Sread_char_exclusive
);
1960 defsubr (&Sread_event
);
1961 defsubr (&Sget_file_char
);
1962 defsubr (&Smapatoms
);
1964 DEFVAR_LISP ("obarray", &Vobarray
,
1965 "Symbol table for use by `intern' and `read'.\n\
1966 It is a vector whose length ought to be prime for best results.\n\
1967 The vector's contents don't make sense if examined from Lisp programs;\n\
1968 to find all the symbols in an obarray, use `mapatoms'.");
1970 DEFVAR_LISP ("values", &Vvalues
,
1971 "List of values of all expressions which were read, evaluated and printed.\n\
1972 Order is reverse chronological.");
1974 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1975 "Stream for read to get input from.\n\
1976 See documentation of `read' for possible values.");
1977 Vstandard_input
= Qt
;
1979 DEFVAR_LISP ("load-path", &Vload_path
,
1980 "*List of directories to search for files to load.\n\
1981 Each element is a string (directory name) or nil (try default directory).\n\
1982 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1983 otherwise to default specified by file `paths.h' when Emacs was built.");
1985 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1986 "Non-nil iff inside of `load'.");
1988 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1989 "An alist of expressions to be evalled when particular files are loaded.\n\
1990 Each element looks like (FILENAME FORMS...).\n\
1991 When `load' is run and the file-name argument is FILENAME,\n\
1992 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1993 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1994 with no directory specified, since that is how `load' is normally called.\n\
1995 An error in FORMS does not undo the load,\n\
1996 but does prevent execution of the rest of the FORMS.");
1997 Vafter_load_alist
= Qnil
;
1999 DEFVAR_LISP ("load-history", &Vload_history
,
2000 "Alist mapping source file names to symbols and features.\n\
2001 Each alist element is a list that starts with a file name,\n\
2002 except for one element (optional) that starts with nil and describes\n\
2003 definitions evaluated from buffers not visiting files.\n\
2004 The remaining elements of each list are symbols defined as functions\n\
2005 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
2006 Vload_history
= Qnil
;
2008 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
2009 "Used for internal purposes by `load'.");
2010 Vcurrent_load_list
= Qnil
;
2012 load_descriptor_list
= Qnil
;
2013 staticpro (&load_descriptor_list
);
2015 Qcurrent_load_list
= intern ("current-load-list");
2016 staticpro (&Qcurrent_load_list
);
2018 Qstandard_input
= intern ("standard-input");
2019 staticpro (&Qstandard_input
);
2021 Qread_char
= intern ("read-char");
2022 staticpro (&Qread_char
);
2024 Qget_file_char
= intern ("get-file-char");
2025 staticpro (&Qget_file_char
);
2027 Qascii_character
= intern ("ascii-character");
2028 staticpro (&Qascii_character
);
2030 Qload
= intern ("load");