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
;
169 /* Don't back up the pointer if we're unreading the end-of-input mark,
170 since readchar didn't advance it when we read it. */
172 else if (XTYPE (readcharfun
) == Lisp_Buffer
)
174 if (XBUFFER (readcharfun
) == current_buffer
)
177 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
179 else if (XTYPE (readcharfun
) == Lisp_Marker
)
180 XMARKER (readcharfun
)->bufpos
--;
181 else if (XTYPE (readcharfun
) == Lisp_String
)
182 read_from_string_index
--;
183 else if (EQ (readcharfun
, Qget_file_char
))
184 ungetc (c
, instream
);
186 call1 (readcharfun
, make_number (c
));
189 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
191 /* get a character from the tty */
193 extern Lisp_Object
read_char ();
195 /* Read input events until we get one that's acceptable for our purposes.
197 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
198 until we get a character we like, and then stuffed into
201 If ASCII_REQUIRED is non-zero, we check function key events to see
202 if the unmodified version of the symbol has a Qascii_character
203 property, and use that character, if present.
205 If ERROR_NONASCII is non-zero, we signal an error if the input we
206 get isn't an ASCII character with modifiers. If it's zero but
207 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
210 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
211 int no_switch_frame
, ascii_required
, error_nonascii
;
214 return make_number (getchar ());
216 register Lisp_Object val
, delayed_switch_frame
;
218 delayed_switch_frame
= Qnil
;
220 /* Read until we get an acceptable event. */
222 val
= read_char (0, 0, 0, Qnil
, 0);
224 if (XTYPE (val
) == Lisp_Buffer
)
227 /* switch-frame events are put off until after the next ASCII
228 character. This is better than signalling an error just because
229 the last characters were typed to a separate minibuffer frame,
230 for example. Eventually, some code which can deal with
231 switch-frame events will read it and process it. */
233 && EVENT_HAS_PARAMETERS (val
)
234 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
236 delayed_switch_frame
= val
;
242 /* Convert certain symbols to their ASCII equivalents. */
243 if (XTYPE (val
) == Lisp_Symbol
)
245 Lisp_Object tem
, tem1
, tem2
;
246 tem
= Fget (val
, Qevent_symbol_element_mask
);
249 tem1
= Fget (Fcar (tem
), Qascii_character
);
250 /* Merge this symbol's modifier bits
251 with the ASCII equivalent of its basic code. */
253 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
257 /* If we don't have a character now, deal with it appropriately. */
258 if (XTYPE (val
) != Lisp_Int
)
262 Vunread_command_events
= Fcons (val
, Qnil
);
263 error ("Non-character input-event");
270 if (! NILP (delayed_switch_frame
))
271 unread_switch_frame
= delayed_switch_frame
;
277 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
278 "Read a character from the command input (keyboard or macro).\n\
279 It is returned as a number.\n\
280 If the user generates an event which is not a character (i.e. a mouse\n\
281 click or function key event), `read-char' signals an error. As an\n\
282 exception, switch-frame events are put off until non-ASCII events can\n\
284 If you want to read non-character events, or ignore them, call\n\
285 `read-event' or `read-char-exclusive' instead.")
288 return read_filtered_event (1, 1, 1);
291 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
292 "Read an event object from the input stream.")
295 return read_filtered_event (0, 0, 0);
298 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
299 "Read a character from the command input (keyboard or macro).\n\
300 It is returned as a number. Non character events are ignored.")
303 return read_filtered_event (1, 1, 0);
306 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
307 "Don't use this yourself.")
310 register Lisp_Object val
;
311 XSET (val
, Lisp_Int
, getc (instream
));
315 static void readevalloop ();
316 static Lisp_Object
load_unwind ();
317 static Lisp_Object
load_descriptor_unwind ();
319 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
320 "Execute a file of Lisp code named FILE.\n\
321 First try FILE with `.elc' appended, then try with `.el',\n\
322 then try FILE unmodified.\n\
323 This function searches the directories in `load-path'.\n\
324 If optional second arg NOERROR is non-nil,\n\
325 report no error if FILE doesn't exist.\n\
326 Print messages at start and end of loading unless\n\
327 optional third arg NOMESSAGE is non-nil.\n\
328 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
329 suffixes `.elc' or `.el' to the specified name FILE.\n\
330 Return t if file exists.")
331 (str
, noerror
, nomessage
, nosuffix
)
332 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
334 register FILE *stream
;
335 register int fd
= -1;
336 register Lisp_Object lispstream
;
338 int count
= specpdl_ptr
- specpdl
;
342 /* 1 means inhibit the message at the beginning. */
346 char *dosmode
= "rt";
349 CHECK_STRING (str
, 0);
350 str
= Fsubstitute_in_file_name (str
);
352 /* If file name is magic, call the handler. */
353 handler
= Ffind_file_name_handler (str
, Qload
);
355 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
357 /* Avoid weird lossage with null string as arg,
358 since it would try to load a directory as a Lisp file */
359 if (XSTRING (str
)->size
> 0)
362 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
371 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
377 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
386 stat ((char *)XSTRING (found
)->data
, &s1
);
387 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
388 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
389 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
391 message ("Source file `%s' newer than byte-compiled file",
392 XSTRING (found
)->data
);
393 /* Don't immediately overwrite this message. */
397 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
402 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
404 stream
= fdopen (fd
, "r");
409 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
412 if (NILP (nomessage
) && !nomessage1
)
413 message ("Loading %s...", XSTRING (str
)->data
);
416 /* We may not be able to store STREAM itself as a Lisp_Object pointer
417 since that is guaranteed to work only for data that has been malloc'd.
418 So malloc a full-size pointer, and record the address of that pointer. */
419 ptr
= (FILE **) xmalloc (sizeof (FILE *));
421 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
422 record_unwind_protect (load_unwind
, lispstream
);
423 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
425 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
427 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
428 unbind_to (count
, Qnil
);
430 /* Run any load-hooks for this file. */
431 temp
= Fassoc (str
, Vafter_load_alist
);
433 Fprogn (Fcdr (temp
));
436 if (!noninteractive
&& NILP (nomessage
))
437 message ("Loading %s...done", XSTRING (str
)->data
);
442 load_unwind (stream
) /* used as unwind-protect function in load */
445 fclose (*(FILE **) XSTRING (stream
));
446 xfree (XPNTR (stream
));
447 if (--load_in_progress
< 0) load_in_progress
= 0;
452 load_descriptor_unwind (oldlist
)
455 load_descriptor_list
= oldlist
;
458 /* Close all descriptors in use for Floads.
459 This is used when starting a subprocess. */
465 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
466 close (XFASTINT (XCONS (tail
)->car
));
470 complete_filename_p (pathname
)
471 Lisp_Object pathname
;
473 register unsigned char *s
= XSTRING (pathname
)->data
;
481 #ifdef MSDOS /* MW, May 1993 */
482 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
487 /* Search for a file whose name is STR, looking in directories
488 in the Lisp list PATH, and trying suffixes from SUFFIX.
489 SUFFIX is a string containing possible suffixes separated by colons.
490 On success, returns a file descriptor. On failure, returns -1.
492 EXEC_ONLY nonzero means don't open the files,
493 just look for one that is executable. In this case,
494 returns 1 on success.
496 If STOREPTR is nonzero, it points to a slot where the name of
497 the file actually found should be stored as a Lisp string.
498 Nil is stored there on failure. */
501 openp (path
, str
, suffix
, storeptr
, exec_only
)
502 Lisp_Object path
, str
;
504 Lisp_Object
*storeptr
;
510 register char *fn
= buf
;
513 register Lisp_Object filename
;
521 if (complete_filename_p (str
))
524 for (; !NILP (path
); path
= Fcdr (path
))
528 filename
= Fexpand_file_name (str
, Fcar (path
));
529 if (!complete_filename_p (filename
))
530 /* If there are non-absolute elts in PATH (eg ".") */
531 /* Of course, this could conceivably lose if luser sets
532 default-directory to be something non-absolute... */
534 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
535 if (!complete_filename_p (filename
))
536 /* Give up on this path element! */
540 /* Calculate maximum size of any filename made from
541 this path element/specified file name and any possible suffix. */
542 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
543 if (fn_size
< want_size
)
544 fn
= (char *) alloca (fn_size
= 100 + want_size
);
548 /* Loop over suffixes. */
551 char *esuffix
= (char *) index (nsuffix
, ':');
552 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
554 /* Concatenate path element/specified name with the suffix. */
555 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
556 fn
[XSTRING (filename
)->size
] = 0;
557 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
558 strncat (fn
, nsuffix
, lsuffix
);
560 /* Ignore file if it's a directory. */
561 if (stat (fn
, &st
) >= 0
562 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
564 /* Check that we can access or open it. */
566 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
568 fd
= open (fn
, 0, 0);
572 /* We succeeded; return this descriptor and filename. */
574 *storeptr
= build_string (fn
);
579 /* Advance to next suffix. */
582 nsuffix
+= lsuffix
+ 1;
592 /* Merge the list we've accumulated of globals from the current input source
593 into the load_history variable. The details depend on whether
594 the source has an associated file name or not. */
597 build_load_history (stream
, source
)
601 register Lisp_Object tail
, prev
, newelt
;
602 register Lisp_Object tem
, tem2
;
603 register int foundit
, loading
;
605 /* Don't bother recording anything for preloaded files. */
606 if (!NILP (Vpurify_flag
))
609 loading
= stream
|| !NARROWED
;
611 tail
= Vload_history
;
618 /* Find the feature's previous assoc list... */
619 if (!NILP (Fequal (source
, Fcar (tem
))))
623 /* If we're loading, remove it. */
627 Vload_history
= Fcdr (tail
);
629 Fsetcdr (prev
, Fcdr (tail
));
632 /* Otherwise, cons on new symbols that are not already members. */
635 tem2
= Vcurrent_load_list
;
639 newelt
= Fcar (tem2
);
641 if (NILP (Fmemq (newelt
, tem
)))
642 Fsetcar (tail
, Fcons (Fcar (tem
),
643 Fcons (newelt
, Fcdr (tem
))));
656 /* If we're loading, cons the new assoc onto the front of load-history,
657 the most-recently-loaded position. Also do this if we didn't find
658 an existing member for the current source. */
659 if (loading
|| !foundit
)
660 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
665 unreadpure () /* Used as unwind-protect function in readevalloop */
672 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
673 Lisp_Object readcharfun
;
675 Lisp_Object sourcename
;
676 Lisp_Object (*evalfun
) ();
680 register Lisp_Object val
;
681 int count
= specpdl_ptr
- specpdl
;
683 struct buffer
*b
= 0;
685 if (BUFFERP (readcharfun
))
686 b
= XBUFFER (readcharfun
);
687 else if (MARKERP (readcharfun
))
688 b
= XMARKER (readcharfun
)->buffer
;
690 specbind (Qstandard_input
, readcharfun
);
691 specbind (Qcurrent_load_list
, Qnil
);
695 LOADHIST_ATTACH (sourcename
);
699 if (b
!= 0 && NILP (b
->name
))
700 error ("Reading from killed buffer");
706 while ((c
= READCHAR
) != '\n' && c
!= -1);
710 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
712 if (!NILP (Vpurify_flag
) && c
== '(')
714 record_unwind_protect (unreadpure
, Qnil
);
715 val
= read_list (-1, readcharfun
);
716 unbind_to (count
+ 1, Qnil
);
721 val
= read0 (readcharfun
);
724 val
= (*evalfun
) (val
);
727 Vvalues
= Fcons (val
, Vvalues
);
728 if (EQ (Vstandard_output
, Qt
))
735 build_load_history (stream
, sourcename
);
738 unbind_to (count
, Qnil
);
743 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
744 "Execute the current buffer as Lisp code.\n\
745 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
746 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
747 PRINTFLAG controls printing of output:\n\
748 nil means discard it; anything else is stream for print.\n\
750 If there is no error, point does not move. If there is an error,\n\
751 point remains at the end of the last character read from the buffer.")
753 Lisp_Object bufname
, printflag
;
755 int count
= specpdl_ptr
- specpdl
;
756 Lisp_Object tem
, buf
;
759 buf
= Fcurrent_buffer ();
761 buf
= Fget_buffer (bufname
);
763 error ("No such buffer.");
765 if (NILP (printflag
))
769 specbind (Qstandard_output
, tem
);
770 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
771 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
772 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
773 unbind_to (count
, Qnil
);
779 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
780 "Execute the current buffer as Lisp code.\n\
781 Programs can pass argument PRINTFLAG which controls printing of output:\n\
782 nil means discard it; anything else is stream for print.\n\
784 If there is no error, point does not move. If there is an error,\n\
785 point remains at the end of the last character read from the buffer.")
787 Lisp_Object printflag
;
789 int count
= specpdl_ptr
- specpdl
;
790 Lisp_Object tem
, cbuf
;
792 cbuf
= Fcurrent_buffer ()
794 if (NILP (printflag
))
798 specbind (Qstandard_output
, tem
);
799 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
801 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
802 return unbind_to (count
, Qnil
);
806 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
807 "Execute the region as Lisp code.\n\
808 When called from programs, expects two arguments,\n\
809 giving starting and ending indices in the current buffer\n\
810 of the text to be executed.\n\
811 Programs can pass third argument PRINTFLAG which controls output:\n\
812 nil means discard it; anything else is stream for printing it.\n\
814 If there is no error, point does not move. If there is an error,\n\
815 point remains at the end of the last character read from the buffer.")
817 Lisp_Object b
, e
, printflag
;
819 int count
= specpdl_ptr
- specpdl
;
820 Lisp_Object tem
, cbuf
;
822 cbuf
= Fcurrent_buffer ();
824 if (NILP (printflag
))
828 specbind (Qstandard_output
, tem
);
830 if (NILP (printflag
))
831 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
832 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
834 /* This both uses b and checks its type. */
836 Fnarrow_to_region (make_number (BEGV
), e
);
837 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
839 return unbind_to (count
, Qnil
);
842 #endif /* standalone */
844 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
845 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
846 If STREAM is nil, use the value of `standard-input' (which see).\n\
847 STREAM or the value of `standard-input' may be:\n\
848 a buffer (read from point and advance it)\n\
849 a marker (read from where it points and advance it)\n\
850 a function (call it with no arguments for each character,\n\
851 call it with a char as argument to push a char back)\n\
852 a string (takes text from string, starting at the beginning)\n\
853 t (read text line using minibuffer and use it).")
855 Lisp_Object readcharfun
;
857 extern Lisp_Object
Fread_minibuffer ();
859 if (NILP (readcharfun
))
860 readcharfun
= Vstandard_input
;
861 if (EQ (readcharfun
, Qt
))
862 readcharfun
= Qread_char
;
865 if (EQ (readcharfun
, Qread_char
))
866 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
869 if (XTYPE (readcharfun
) == Lisp_String
)
870 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
872 return read0 (readcharfun
);
875 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
876 "Read one Lisp expression which is represented as text by STRING.\n\
877 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
878 START and END optionally delimit a substring of STRING from which to read;\n\
879 they default to 0 and (length STRING) respectively.")
881 Lisp_Object string
, start
, end
;
883 int startval
, endval
;
886 CHECK_STRING (string
,0);
889 endval
= XSTRING (string
)->size
;
891 { CHECK_NUMBER (end
,2);
893 if (endval
< 0 || endval
> XSTRING (string
)->size
)
894 args_out_of_range (string
, end
);
900 { CHECK_NUMBER (start
,1);
901 startval
= XINT (start
);
902 if (startval
< 0 || startval
> endval
)
903 args_out_of_range (string
, start
);
906 read_from_string_index
= startval
;
907 read_from_string_limit
= endval
;
909 tem
= read0 (string
);
910 return Fcons (tem
, make_number (read_from_string_index
));
913 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
917 Lisp_Object readcharfun
;
919 register Lisp_Object val
;
922 val
= read1 (readcharfun
);
923 if (XTYPE (val
) == Lisp_Internal
)
926 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
932 static int read_buffer_size
;
933 static char *read_buffer
;
936 read_escape (readcharfun
)
937 Lisp_Object readcharfun
;
939 register int c
= READCHAR
;
966 error ("Invalid escape character syntax");
969 c
= read_escape (readcharfun
);
970 return c
| meta_modifier
;
975 error ("Invalid escape character syntax");
978 c
= read_escape (readcharfun
);
979 return c
| shift_modifier
;
984 error ("Invalid escape character syntax");
987 c
= read_escape (readcharfun
);
988 return c
| hyper_modifier
;
993 error ("Invalid escape character syntax");
996 c
= read_escape (readcharfun
);
997 return c
| alt_modifier
;
1002 error ("Invalid escape character syntax");
1005 c
= read_escape (readcharfun
);
1006 return c
| super_modifier
;
1011 error ("Invalid escape character syntax");
1015 c
= read_escape (readcharfun
);
1016 if ((c
& 0177) == '?')
1018 /* ASCII control chars are made from letters (both cases),
1019 as well as the non-letters within 0100...0137. */
1020 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1021 return (c
& (037 | ~0177));
1022 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1023 return (c
& (037 | ~0177));
1025 return c
| ctrl_modifier
;
1035 /* An octal escape, as in ANSI C. */
1037 register int i
= c
- '0';
1038 register int count
= 0;
1041 if ((c
= READCHAR
) >= '0' && c
<= '7')
1056 /* A hex escape, as in ANSI C. */
1062 if (c
>= '0' && c
<= '9')
1067 else if ((c
>= 'a' && c
<= 'f')
1068 || (c
>= 'A' && c
<= 'F'))
1071 if (c
>= 'a' && c
<= 'f')
1092 register Lisp_Object readcharfun
;
1099 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1104 return read_list (0, readcharfun
);
1107 return read_vector (readcharfun
);
1112 register Lisp_Object val
;
1113 XSET (val
, Lisp_Internal
, c
);
1121 /* Accept compiled functions at read-time so that we don't have to
1122 build them using function calls. */
1124 tmp
= read_vector (readcharfun
);
1125 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1126 XVECTOR (tmp
)->contents
);
1128 #ifdef USE_TEXT_PROPERTIES
1132 struct gcpro gcpro1
;
1134 /* Read the string itself. */
1135 tmp
= read1 (readcharfun
);
1136 if (XTYPE (tmp
) != Lisp_String
)
1137 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1139 /* Read the intervals and their properties. */
1142 Lisp_Object beg
, end
, plist
;
1144 beg
= read1 (readcharfun
);
1145 if (XTYPE (beg
) == Lisp_Internal
)
1147 if (XINT (beg
) == ')')
1149 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1151 end
= read1 (readcharfun
);
1152 if (XTYPE (end
) == Lisp_Internal
)
1153 Fsignal (Qinvalid_read_syntax
,
1154 Fcons (make_string ("invalid string property list", 28), Qnil
));
1156 plist
= read1 (readcharfun
);
1157 if (XTYPE (plist
) == Lisp_Internal
)
1158 Fsignal (Qinvalid_read_syntax
,
1159 Fcons (make_string ("invalid string property list", 28), Qnil
));
1160 Fset_text_properties (beg
, end
, plist
, tmp
);
1167 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1170 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1175 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1180 register Lisp_Object val
;
1183 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1186 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1188 XSET (val
, Lisp_Int
, c
);
1195 register char *p
= read_buffer
;
1196 register char *end
= read_buffer
+ read_buffer_size
;
1200 while ((c
= READCHAR
) >= 0
1205 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1206 p
+= new - read_buffer
;
1207 read_buffer
+= new - read_buffer
;
1208 end
= read_buffer
+ read_buffer_size
;
1211 c
= read_escape (readcharfun
);
1212 /* c is -1 if \ newline has just been seen */
1215 if (p
== read_buffer
)
1220 /* Allow `\C- ' and `\C-?'. */
1221 if (c
== (CHAR_CTL
| ' '))
1223 else if (c
== (CHAR_CTL
| '?'))
1227 /* Move the meta bit to the right place for a string. */
1228 c
= (c
& ~CHAR_META
) | 0x80;
1230 error ("Invalid modifier in string");
1234 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1236 /* If purifying, and string starts with \ newline,
1237 return zero instead. This is for doc strings
1238 that we are really going to find in etc/DOC.nn.nn */
1239 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1240 return make_number (0);
1243 return make_pure_string (read_buffer
, p
- read_buffer
);
1245 return make_string (read_buffer
, p
- read_buffer
);
1250 #ifdef LISP_FLOAT_TYPE
1251 /* If a period is followed by a number, then we should read it
1252 as a floating point number. Otherwise, it denotes a dotted
1254 int next_char
= READCHAR
;
1257 if (! isdigit (next_char
))
1260 register Lisp_Object val
;
1261 XSET (val
, Lisp_Internal
, c
);
1265 /* Otherwise, we fall through! Note that the atom-reading loop
1266 below will now loop at least once, assuring that we will not
1267 try to UNREAD two characters in a row. */
1270 if (c
<= 040) goto retry
;
1272 register char *p
= read_buffer
;
1276 register char *end
= read_buffer
+ read_buffer_size
;
1279 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1280 || c
== '(' || c
== ')'
1281 #ifndef LISP_FLOAT_TYPE
1282 /* If we have floating-point support, then we need
1283 to allow <digits><dot><digits>. */
1285 #endif /* not LISP_FLOAT_TYPE */
1286 || c
== '[' || c
== ']' || c
== '#'
1291 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1292 p
+= new - read_buffer
;
1293 read_buffer
+= new - read_buffer
;
1294 end
= read_buffer
+ read_buffer_size
;
1307 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1308 p
+= new - read_buffer
;
1309 read_buffer
+= new - read_buffer
;
1310 /* end = read_buffer + read_buffer_size; */
1320 register Lisp_Object val
;
1322 if (*p1
== '+' || *p1
== '-') p1
++;
1323 /* Is it an integer? */
1326 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1327 #ifdef LISP_FLOAT_TYPE
1328 /* Integers can have trailing decimal points. */
1329 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1332 /* It is an integer. */
1334 #ifdef LISP_FLOAT_TYPE
1338 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1342 #ifdef LISP_FLOAT_TYPE
1343 if (isfloat_string (read_buffer
))
1344 return make_float (atof (read_buffer
));
1348 return intern (read_buffer
);
1353 #ifdef LISP_FLOAT_TYPE
1368 if (*cp
== '+' || *cp
== '-')
1374 while (isdigit (*cp
))
1385 while (isdigit (*cp
))
1393 if ((*cp
== '+') || (*cp
== '-'))
1399 while (isdigit (*cp
))
1403 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1404 || state
== (DOT_CHAR
|TRAIL_INT
)
1405 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1406 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1407 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1409 #endif /* LISP_FLOAT_TYPE */
1412 read_vector (readcharfun
)
1413 Lisp_Object readcharfun
;
1417 register Lisp_Object
*ptr
;
1418 register Lisp_Object tem
, vector
;
1419 register struct Lisp_Cons
*otem
;
1422 tem
= read_list (1, readcharfun
);
1423 len
= Flength (tem
);
1424 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1427 size
= XVECTOR (vector
)->size
;
1428 ptr
= XVECTOR (vector
)->contents
;
1429 for (i
= 0; i
< size
; i
++)
1431 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1439 /* flag = 1 means check for ] to terminate rather than ) and .
1440 flag = -1 means check for starting with defun
1441 and make structure pure. */
1444 read_list (flag
, readcharfun
)
1446 register Lisp_Object readcharfun
;
1448 /* -1 means check next element for defun,
1449 0 means don't check,
1450 1 means already checked and found defun. */
1451 int defunflag
= flag
< 0 ? -1 : 0;
1452 Lisp_Object val
, tail
;
1453 register Lisp_Object elt
, tem
;
1454 struct gcpro gcpro1
, gcpro2
;
1462 elt
= read1 (readcharfun
);
1464 if (XTYPE (elt
) == Lisp_Internal
)
1468 if (XINT (elt
) == ']')
1470 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1472 if (XINT (elt
) == ')')
1474 if (XINT (elt
) == '.')
1478 XCONS (tail
)->cdr
= read0 (readcharfun
);
1480 val
= read0 (readcharfun
);
1481 elt
= read1 (readcharfun
);
1483 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1485 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1487 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1489 tem
= (read_pure
&& flag
<= 0
1490 ? pure_cons (elt
, Qnil
)
1491 : Fcons (elt
, Qnil
));
1493 XCONS (tail
)->cdr
= tem
;
1498 defunflag
= EQ (elt
, Qdefun
);
1499 else if (defunflag
> 0)
1504 Lisp_Object Vobarray
;
1505 Lisp_Object initial_obarray
;
1508 check_obarray (obarray
)
1509 Lisp_Object obarray
;
1511 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1513 /* If Vobarray is now invalid, force it to be valid. */
1514 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1516 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1521 static int hash_string ();
1522 Lisp_Object
oblookup ();
1529 int len
= strlen (str
);
1530 Lisp_Object obarray
;
1533 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1534 obarray
= check_obarray (obarray
);
1535 tem
= oblookup (obarray
, str
, len
);
1536 if (XTYPE (tem
) == Lisp_Symbol
)
1538 return Fintern ((!NILP (Vpurify_flag
)
1539 ? make_pure_string (str
, len
)
1540 : make_string (str
, len
)),
1544 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1545 "Return the canonical symbol whose name is STRING.\n\
1546 If there is none, one is created by this function and returned.\n\
1547 A second optional argument specifies the obarray to use;\n\
1548 it defaults to the value of `obarray'.")
1550 Lisp_Object str
, obarray
;
1552 register Lisp_Object tem
, sym
, *ptr
;
1554 if (NILP (obarray
)) obarray
= Vobarray
;
1555 obarray
= check_obarray (obarray
);
1557 CHECK_STRING (str
, 0);
1559 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1560 if (XTYPE (tem
) != Lisp_Int
)
1563 if (!NILP (Vpurify_flag
))
1564 str
= Fpurecopy (str
);
1565 sym
= Fmake_symbol (str
);
1567 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1568 if (XTYPE (*ptr
) == Lisp_Symbol
)
1569 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1571 XSYMBOL (sym
)->next
= 0;
1576 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1577 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1578 A second optional argument specifies the obarray to use;\n\
1579 it defaults to the value of `obarray'.")
1581 Lisp_Object str
, obarray
;
1583 register Lisp_Object tem
;
1585 if (NILP (obarray
)) obarray
= Vobarray
;
1586 obarray
= check_obarray (obarray
);
1588 CHECK_STRING (str
, 0);
1590 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1591 if (XTYPE (tem
) != Lisp_Int
)
1597 oblookup (obarray
, ptr
, size
)
1598 Lisp_Object obarray
;
1603 register Lisp_Object tail
;
1604 Lisp_Object bucket
, tem
;
1606 if (XTYPE (obarray
) != Lisp_Vector
1607 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1609 obarray
= check_obarray (obarray
);
1610 obsize
= XVECTOR (obarray
)->size
;
1612 /* Combining next two lines breaks VMS C 2.3. */
1613 hash
= hash_string (ptr
, size
);
1615 bucket
= XVECTOR (obarray
)->contents
[hash
];
1616 if (XFASTINT (bucket
) == 0)
1618 else if (XTYPE (bucket
) != Lisp_Symbol
)
1619 error ("Bad data in guts of obarray"); /* Like CADR error message */
1620 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1622 if (XSYMBOL (tail
)->name
->size
== size
&&
1623 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1625 else if (XSYMBOL (tail
)->next
== 0)
1628 XSET (tem
, Lisp_Int
, hash
);
1633 hash_string (ptr
, len
)
1637 register unsigned char *p
= ptr
;
1638 register unsigned char *end
= p
+ len
;
1639 register unsigned char c
;
1640 register int hash
= 0;
1645 if (c
>= 0140) c
-= 40;
1646 hash
= ((hash
<<3) + (hash
>>28) + c
);
1648 return hash
& 07777777777;
1652 map_obarray (obarray
, fn
, arg
)
1653 Lisp_Object obarray
;
1658 register Lisp_Object tail
;
1659 CHECK_VECTOR (obarray
, 1);
1660 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1662 tail
= XVECTOR (obarray
)->contents
[i
];
1663 if (XFASTINT (tail
) != 0)
1667 if (XSYMBOL (tail
)->next
== 0)
1669 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1674 mapatoms_1 (sym
, function
)
1675 Lisp_Object sym
, function
;
1677 call1 (function
, sym
);
1680 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1681 "Call FUNCTION on every symbol in OBARRAY.\n\
1682 OBARRAY defaults to the value of `obarray'.")
1684 Lisp_Object function
, obarray
;
1688 if (NILP (obarray
)) obarray
= Vobarray
;
1689 obarray
= check_obarray (obarray
);
1691 map_obarray (obarray
, mapatoms_1
, function
);
1695 #define OBARRAY_SIZE 1511
1700 Lisp_Object oblength
;
1704 XFASTINT (oblength
) = OBARRAY_SIZE
;
1706 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1707 Vobarray
= Fmake_vector (oblength
, make_number (0));
1708 initial_obarray
= Vobarray
;
1709 staticpro (&initial_obarray
);
1710 /* Intern nil in the obarray */
1711 /* These locals are to kludge around a pyramid compiler bug. */
1712 hash
= hash_string ("nil", 3);
1713 /* Separate statement here to avoid VAXC bug. */
1714 hash
%= OBARRAY_SIZE
;
1715 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1718 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1719 XSYMBOL (Qnil
)->function
= Qunbound
;
1720 XSYMBOL (Qunbound
)->value
= Qunbound
;
1721 XSYMBOL (Qunbound
)->function
= Qunbound
;
1724 XSYMBOL (Qnil
)->value
= Qnil
;
1725 XSYMBOL (Qnil
)->plist
= Qnil
;
1726 XSYMBOL (Qt
)->value
= Qt
;
1728 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1731 Qvariable_documentation
= intern ("variable-documentation");
1733 read_buffer_size
= 100;
1734 read_buffer
= (char *) malloc (read_buffer_size
);
1739 struct Lisp_Subr
*sname
;
1742 sym
= intern (sname
->symbol_name
);
1743 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1746 #ifdef NOTDEF /* use fset in subr.el now */
1748 defalias (sname
, string
)
1749 struct Lisp_Subr
*sname
;
1753 sym
= intern (string
);
1754 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1758 /* New replacement for DefIntVar; it ignores the doc string argument
1759 on the assumption that make-docfile will handle that. */
1760 /* Define an "integer variable"; a symbol whose value is forwarded
1761 to a C variable of type int. Sample call: */
1762 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1765 defvar_int (namestring
, address
, doc
)
1771 sym
= intern (namestring
);
1772 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1775 /* Similar but define a variable whose value is T if address contains 1,
1776 NIL if address contains 0 */
1779 defvar_bool (namestring
, address
, doc
)
1785 sym
= intern (namestring
);
1786 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1789 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1792 defvar_lisp (namestring
, address
, doc
)
1794 Lisp_Object
*address
;
1798 sym
= intern (namestring
);
1799 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1800 staticpro (address
);
1803 /* Similar but don't request gc-marking of the C variable.
1804 Used when that variable will be gc-marked for some other reason,
1805 since marking the same slot twice can cause trouble with strings. */
1808 defvar_lisp_nopro (namestring
, address
, doc
)
1810 Lisp_Object
*address
;
1814 sym
= intern (namestring
);
1815 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1820 /* Similar but define a variable whose value is the Lisp Object stored in
1821 the current buffer. address is the address of the slot in the buffer that is current now. */
1824 defvar_per_buffer (namestring
, address
, type
, doc
)
1826 Lisp_Object
*address
;
1832 extern struct buffer buffer_local_symbols
;
1834 sym
= intern (namestring
);
1835 offset
= (char *)address
- (char *)current_buffer
;
1837 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1838 (Lisp_Object
*) offset
);
1839 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1840 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1841 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1842 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1843 slot of buffer_local_flags */
1847 #endif /* standalone */
1853 /* Compute the default load-path. */
1855 normal
= PATH_LOADSEARCH
;
1856 Vload_path
= decode_env_path (0, normal
);
1858 if (NILP (Vpurify_flag
))
1859 normal
= PATH_LOADSEARCH
;
1861 normal
= PATH_DUMPLOADSEARCH
;
1863 /* In a dumped Emacs, we normally have to reset the value of
1864 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1865 uses ../lisp, instead of the path of the installed elisp
1866 libraries. However, if it appears that Vload_path was changed
1867 from the default before dumping, don't override that value. */
1870 Lisp_Object dump_path
;
1872 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1873 if (! NILP (Fequal (dump_path
, Vload_path
)))
1875 Vload_path
= decode_env_path (0, normal
);
1876 if (!NILP (Vinstallation_directory
))
1878 /* Add to the path the lisp subdir of the
1879 installation dir, if it exists. */
1880 Lisp_Object tem
, tem1
;
1881 tem
= Fexpand_file_name (build_string ("lisp"),
1882 Vinstallation_directory
);
1883 tem1
= Ffile_exists_p (tem
);
1886 if (NILP (Fmember (tem
, Vload_path
)))
1887 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1890 /* That dir doesn't exist, so add the build-time
1891 Lisp dirs instead. */
1892 Vload_path
= nconc2 (Vload_path
, dump_path
);
1897 Vload_path
= decode_env_path (0, normal
);
1900 /* Warn if dirs in the *standard* path don't exist. */
1902 Lisp_Object path_tail
;
1904 for (path_tail
= Vload_path
;
1906 path_tail
= XCONS (path_tail
)->cdr
)
1908 Lisp_Object dirfile
;
1909 dirfile
= Fcar (path_tail
);
1910 if (XTYPE (dirfile
) == Lisp_String
)
1912 dirfile
= Fdirectory_file_name (dirfile
);
1913 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1915 "Warning: Lisp directory `%s' does not exist.\n",
1916 XSTRING (Fcar (path_tail
))->data
);
1921 /* If the EMACSLOADPATH environment variable is set, use its value.
1922 This doesn't apply if we're dumping. */
1923 if (NILP (Vpurify_flag
)
1924 && egetenv ("EMACSLOADPATH"))
1925 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1929 load_in_progress
= 0;
1931 load_descriptor_list
= Qnil
;
1938 defsubr (&Sread_from_string
);
1940 defsubr (&Sintern_soft
);
1942 defsubr (&Seval_buffer
);
1943 defsubr (&Seval_region
);
1944 defsubr (&Sread_char
);
1945 defsubr (&Sread_char_exclusive
);
1946 defsubr (&Sread_event
);
1947 defsubr (&Sget_file_char
);
1948 defsubr (&Smapatoms
);
1950 DEFVAR_LISP ("obarray", &Vobarray
,
1951 "Symbol table for use by `intern' and `read'.\n\
1952 It is a vector whose length ought to be prime for best results.\n\
1953 The vector's contents don't make sense if examined from Lisp programs;\n\
1954 to find all the symbols in an obarray, use `mapatoms'.");
1956 DEFVAR_LISP ("values", &Vvalues
,
1957 "List of values of all expressions which were read, evaluated and printed.\n\
1958 Order is reverse chronological.");
1960 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1961 "Stream for read to get input from.\n\
1962 See documentation of `read' for possible values.");
1963 Vstandard_input
= Qt
;
1965 DEFVAR_LISP ("load-path", &Vload_path
,
1966 "*List of directories to search for files to load.\n\
1967 Each element is a string (directory name) or nil (try default directory).\n\
1968 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1969 otherwise to default specified by file `paths.h' when Emacs was built.");
1971 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1972 "Non-nil iff inside of `load'.");
1974 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1975 "An alist of expressions to be evalled when particular files are loaded.\n\
1976 Each element looks like (FILENAME FORMS...).\n\
1977 When `load' is run and the file-name argument is FILENAME,\n\
1978 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1979 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1980 with no directory specified, since that is how `load' is normally called.\n\
1981 An error in FORMS does not undo the load,\n\
1982 but does prevent execution of the rest of the FORMS.");
1983 Vafter_load_alist
= Qnil
;
1985 DEFVAR_LISP ("load-history", &Vload_history
,
1986 "Alist mapping source file names to symbols and features.\n\
1987 Each alist element is a list that starts with a file name,\n\
1988 except for one element (optional) that starts with nil and describes\n\
1989 definitions evaluated from buffers not visiting files.\n\
1990 The remaining elements of each list are symbols defined as functions\n\
1991 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1992 Vload_history
= Qnil
;
1994 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1995 "Used for internal purposes by `load'.");
1996 Vcurrent_load_list
= Qnil
;
1998 load_descriptor_list
= Qnil
;
1999 staticpro (&load_descriptor_list
);
2001 Qcurrent_load_list
= intern ("current-load-list");
2002 staticpro (&Qcurrent_load_list
);
2004 Qstandard_input
= intern ("standard-input");
2005 staticpro (&Qstandard_input
);
2007 Qread_char
= intern ("read-char");
2008 staticpro (&Qread_char
);
2010 Qget_file_char
= intern ("get-file-char");
2011 staticpro (&Qget_file_char
);
2013 Qascii_character
= intern ("ascii-character");
2014 staticpro (&Qascii_character
);
2016 Qload
= intern ("load");