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>
35 #include "termhooks.h"
39 #include <sys/inode.h>
46 #ifdef LISP_FLOAT_TYPE
53 /* These are redefined (correctly, but differently) in values.h. */
60 #endif /* LISP_FLOAT_TYPE */
62 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
63 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
64 Lisp_Object Qascii_character
, Qload
;
66 extern Lisp_Object Qevent_symbol_element_mask
;
68 /* non-zero if inside `load' */
71 /* Search path for files to be loaded. */
72 Lisp_Object Vload_path
;
74 /* This is the user-visible association list that maps features to
75 lists of defs in their load files. */
76 Lisp_Object Vload_history
;
78 /* This is useud to build the load history. */
79 Lisp_Object Vcurrent_load_list
;
81 /* List of descriptors now open for Fload. */
82 static Lisp_Object load_descriptor_list
;
84 /* File for get_file_char to read from. Use by load */
85 static FILE *instream
;
87 /* When nonzero, read conses in pure space */
90 /* For use within read-from-string (this reader is non-reentrant!!) */
91 static int read_from_string_index
;
92 static int read_from_string_limit
;
94 /* Handle unreading and rereading of characters.
95 Write READCHAR to read a character,
96 UNREAD(c) to unread c to be read again. */
98 #define READCHAR readchar (readcharfun)
99 #define UNREAD(c) unreadchar (readcharfun, c)
102 readchar (readcharfun
)
103 Lisp_Object readcharfun
;
106 register struct buffer
*inbuffer
;
107 register int c
, mpos
;
109 if (XTYPE (readcharfun
) == Lisp_Buffer
)
111 inbuffer
= XBUFFER (readcharfun
);
113 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
115 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
116 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
120 if (XTYPE (readcharfun
) == Lisp_Marker
)
122 inbuffer
= XMARKER (readcharfun
)->buffer
;
124 mpos
= marker_position (readcharfun
);
126 if (mpos
> BUF_ZV (inbuffer
) - 1)
128 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
129 if (mpos
!= BUF_GPT (inbuffer
))
130 XMARKER (readcharfun
)->bufpos
++;
132 Fset_marker (readcharfun
, make_number (mpos
+ 1),
133 Fmarker_buffer (readcharfun
));
136 if (EQ (readcharfun
, Qget_file_char
))
137 return getc (instream
);
139 if (XTYPE (readcharfun
) == Lisp_String
)
142 /* This used to be return of a conditional expression,
143 but that truncated -1 to a char on VMS. */
144 if (read_from_string_index
< read_from_string_limit
)
145 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
151 tem
= call0 (readcharfun
);
158 /* Unread the character C in the way appropriate for the stream READCHARFUN.
159 If the stream is a user function, call it with the char as argument. */
162 unreadchar (readcharfun
, c
)
163 Lisp_Object readcharfun
;
167 /* Don't back up the pointer if we're unreading the end-of-input mark,
168 since readchar didn't advance it when we read it. */
170 else if (XTYPE (readcharfun
) == Lisp_Buffer
)
172 if (XBUFFER (readcharfun
) == current_buffer
)
175 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
177 else if (XTYPE (readcharfun
) == Lisp_Marker
)
178 XMARKER (readcharfun
)->bufpos
--;
179 else if (XTYPE (readcharfun
) == Lisp_String
)
180 read_from_string_index
--;
181 else if (EQ (readcharfun
, Qget_file_char
))
182 ungetc (c
, instream
);
184 call1 (readcharfun
, make_number (c
));
187 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
189 /* get a character from the tty */
191 extern Lisp_Object
read_char ();
193 /* Read input events until we get one that's acceptable for our purposes.
195 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
196 until we get a character we like, and then stuffed into
199 If ASCII_REQUIRED is non-zero, we check function key events to see
200 if the unmodified version of the symbol has a Qascii_character
201 property, and use that character, if present.
203 If ERROR_NONASCII is non-zero, we signal an error if the input we
204 get isn't an ASCII character with modifiers. If it's zero but
205 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
208 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
209 int no_switch_frame
, ascii_required
, error_nonascii
;
212 return make_number (getchar ());
214 register Lisp_Object val
, delayed_switch_frame
;
216 delayed_switch_frame
= Qnil
;
218 /* Read until we get an acceptable event. */
220 val
= read_char (0, 0, 0, Qnil
, 0);
222 if (XTYPE (val
) == Lisp_Buffer
)
225 /* switch-frame events are put off until after the next ASCII
226 character. This is better than signalling an error just because
227 the last characters were typed to a separate minibuffer frame,
228 for example. Eventually, some code which can deal with
229 switch-frame events will read it and process it. */
231 && EVENT_HAS_PARAMETERS (val
)
232 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
234 delayed_switch_frame
= val
;
240 /* Convert certain symbols to their ASCII equivalents. */
241 if (XTYPE (val
) == Lisp_Symbol
)
243 Lisp_Object tem
, tem1
, tem2
;
244 tem
= Fget (val
, Qevent_symbol_element_mask
);
247 tem1
= Fget (Fcar (tem
), Qascii_character
);
248 /* Merge this symbol's modifier bits
249 with the ASCII equivalent of its basic code. */
251 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
255 /* If we don't have a character now, deal with it appropriately. */
256 if (XTYPE (val
) != Lisp_Int
)
260 Vunread_command_events
= Fcons (val
, Qnil
);
261 error ("Non-character input-event");
268 if (! NILP (delayed_switch_frame
))
269 unread_switch_frame
= delayed_switch_frame
;
275 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
276 "Read a character from the command input (keyboard or macro).\n\
277 It is returned as a number.\n\
278 If the user generates an event which is not a character (i.e. a mouse\n\
279 click or function key event), `read-char' signals an error. As an\n\
280 exception, switch-frame events are put off until non-ASCII events can\n\
282 If you want to read non-character events, or ignore them, call\n\
283 `read-event' or `read-char-exclusive' instead.")
286 return read_filtered_event (1, 1, 1);
289 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
290 "Read an event object from the input stream.")
293 return read_filtered_event (0, 0, 0);
296 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
297 "Read a character from the command input (keyboard or macro).\n\
298 It is returned as a number. Non character events are ignored.")
301 return read_filtered_event (1, 1, 0);
304 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
305 "Don't use this yourself.")
308 register Lisp_Object val
;
309 XSET (val
, Lisp_Int
, getc (instream
));
313 static void readevalloop ();
314 static Lisp_Object
load_unwind ();
315 static Lisp_Object
load_descriptor_unwind ();
317 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
318 "Execute a file of Lisp code named FILE.\n\
319 First try FILE with `.elc' appended, then try with `.el',\n\
320 then try FILE unmodified.\n\
321 This function searches the directories in `load-path'.\n\
322 If optional second arg NOERROR is non-nil,\n\
323 report no error if FILE doesn't exist.\n\
324 Print messages at start and end of loading unless\n\
325 optional third arg NOMESSAGE is non-nil.\n\
326 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
327 suffixes `.elc' or `.el' to the specified name FILE.\n\
328 Return t if file exists.")
329 (str
, noerror
, nomessage
, nosuffix
)
330 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
332 register FILE *stream
;
333 register int fd
= -1;
334 register Lisp_Object lispstream
;
336 int count
= specpdl_ptr
- specpdl
;
340 /* 1 means inhibit the message at the beginning. */
344 char *dosmode
= "rt";
347 CHECK_STRING (str
, 0);
348 str
= Fsubstitute_in_file_name (str
);
350 /* If file name is magic, call the handler. */
351 handler
= Ffind_file_name_handler (str
, Qload
);
353 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
355 /* Avoid weird lossage with null string as arg,
356 since it would try to load a directory as a Lisp file */
357 if (XSTRING (str
)->size
> 0)
360 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
369 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
375 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
384 stat ((char *)XSTRING (found
)->data
, &s1
);
385 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
386 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
387 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
389 message ("Source file `%s' newer than byte-compiled file",
390 XSTRING (found
)->data
);
391 /* Don't immediately overwrite this message. */
395 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
400 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
402 stream
= fdopen (fd
, "r");
407 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
410 if (NILP (nomessage
) && !nomessage1
)
411 message ("Loading %s...", XSTRING (str
)->data
);
414 /* We may not be able to store STREAM itself as a Lisp_Object pointer
415 since that is guaranteed to work only for data that has been malloc'd.
416 So malloc a full-size pointer, and record the address of that pointer. */
417 ptr
= (FILE **) xmalloc (sizeof (FILE *));
419 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
420 record_unwind_protect (load_unwind
, lispstream
);
421 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
423 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
425 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
426 unbind_to (count
, Qnil
);
428 /* Run any load-hooks for this file. */
429 temp
= Fassoc (str
, Vafter_load_alist
);
431 Fprogn (Fcdr (temp
));
434 if (!noninteractive
&& NILP (nomessage
))
435 message ("Loading %s...done", XSTRING (str
)->data
);
440 load_unwind (stream
) /* used as unwind-protect function in load */
443 fclose (*(FILE **) XSTRING (stream
));
444 xfree (XPNTR (stream
));
445 if (--load_in_progress
< 0) load_in_progress
= 0;
450 load_descriptor_unwind (oldlist
)
453 load_descriptor_list
= oldlist
;
456 /* Close all descriptors in use for Floads.
457 This is used when starting a subprocess. */
463 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
464 close (XFASTINT (XCONS (tail
)->car
));
468 complete_filename_p (pathname
)
469 Lisp_Object pathname
;
471 register unsigned char *s
= XSTRING (pathname
)->data
;
479 #ifdef MSDOS /* MW, May 1993 */
480 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
485 /* Search for a file whose name is STR, looking in directories
486 in the Lisp list PATH, and trying suffixes from SUFFIX.
487 SUFFIX is a string containing possible suffixes separated by colons.
488 On success, returns a file descriptor. On failure, returns -1.
490 EXEC_ONLY nonzero means don't open the files,
491 just look for one that is executable. In this case,
492 returns 1 on success.
494 If STOREPTR is nonzero, it points to a slot where the name of
495 the file actually found should be stored as a Lisp string.
496 Nil is stored there on failure. */
499 openp (path
, str
, suffix
, storeptr
, exec_only
)
500 Lisp_Object path
, str
;
502 Lisp_Object
*storeptr
;
508 register char *fn
= buf
;
511 register Lisp_Object filename
;
519 if (complete_filename_p (str
))
522 for (; !NILP (path
); path
= Fcdr (path
))
526 filename
= Fexpand_file_name (str
, Fcar (path
));
527 if (!complete_filename_p (filename
))
528 /* If there are non-absolute elts in PATH (eg ".") */
529 /* Of course, this could conceivably lose if luser sets
530 default-directory to be something non-absolute... */
532 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
533 if (!complete_filename_p (filename
))
534 /* Give up on this path element! */
538 /* Calculate maximum size of any filename made from
539 this path element/specified file name and any possible suffix. */
540 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
541 if (fn_size
< want_size
)
542 fn
= (char *) alloca (fn_size
= 100 + want_size
);
546 /* Loop over suffixes. */
549 char *esuffix
= (char *) index (nsuffix
, ':');
550 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
552 /* Concatenate path element/specified name with the suffix. */
553 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
554 fn
[XSTRING (filename
)->size
] = 0;
555 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
556 strncat (fn
, nsuffix
, lsuffix
);
558 /* Ignore file if it's a directory. */
559 if (stat (fn
, &st
) >= 0
560 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
562 /* Check that we can access or open it. */
564 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
566 fd
= open (fn
, 0, 0);
570 /* We succeeded; return this descriptor and filename. */
572 *storeptr
= build_string (fn
);
577 /* Advance to next suffix. */
580 nsuffix
+= lsuffix
+ 1;
590 /* Merge the list we've accumulated of globals from the current input source
591 into the load_history variable. The details depend on whether
592 the source has an associated file name or not. */
595 build_load_history (stream
, source
)
599 register Lisp_Object tail
, prev
, newelt
;
600 register Lisp_Object tem
, tem2
;
601 register int foundit
, loading
;
603 /* Don't bother recording anything for preloaded files. */
604 if (!NILP (Vpurify_flag
))
607 loading
= stream
|| !NARROWED
;
609 tail
= Vload_history
;
616 /* Find the feature's previous assoc list... */
617 if (!NILP (Fequal (source
, Fcar (tem
))))
621 /* If we're loading, remove it. */
625 Vload_history
= Fcdr (tail
);
627 Fsetcdr (prev
, Fcdr (tail
));
630 /* Otherwise, cons on new symbols that are not already members. */
633 tem2
= Vcurrent_load_list
;
637 newelt
= Fcar (tem2
);
639 if (NILP (Fmemq (newelt
, tem
)))
640 Fsetcar (tail
, Fcons (Fcar (tem
),
641 Fcons (newelt
, Fcdr (tem
))));
654 /* If we're loading, cons the new assoc onto the front of load-history,
655 the most-recently-loaded position. Also do this if we didn't find
656 an existing member for the current source. */
657 if (loading
|| !foundit
)
658 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
663 unreadpure () /* Used as unwind-protect function in readevalloop */
670 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
671 Lisp_Object readcharfun
;
673 Lisp_Object sourcename
;
674 Lisp_Object (*evalfun
) ();
678 register Lisp_Object val
;
679 int count
= specpdl_ptr
- specpdl
;
681 struct buffer
*b
= 0;
683 if (BUFFERP (readcharfun
))
684 b
= XBUFFER (readcharfun
);
685 else if (MARKERP (readcharfun
))
686 b
= XMARKER (readcharfun
)->buffer
;
688 specbind (Qstandard_input
, readcharfun
);
689 specbind (Qcurrent_load_list
, Qnil
);
693 LOADHIST_ATTACH (sourcename
);
697 if (b
!= 0 && NILP (b
->name
))
698 error ("Reading from killed buffer");
704 while ((c
= READCHAR
) != '\n' && c
!= -1);
708 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
710 if (!NILP (Vpurify_flag
) && c
== '(')
712 record_unwind_protect (unreadpure
, Qnil
);
713 val
= read_list (-1, readcharfun
);
714 unbind_to (count
+ 1, Qnil
);
719 val
= read0 (readcharfun
);
722 val
= (*evalfun
) (val
);
725 Vvalues
= Fcons (val
, Vvalues
);
726 if (EQ (Vstandard_output
, Qt
))
733 build_load_history (stream
, sourcename
);
736 unbind_to (count
, Qnil
);
741 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
742 "Execute the current buffer as Lisp code.\n\
743 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
744 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
745 PRINTFLAG controls printing of output:\n\
746 nil means discard it; anything else is stream for print.\n\
748 If there is no error, point does not move. If there is an error,\n\
749 point remains at the end of the last character read from the buffer.")
751 Lisp_Object bufname
, printflag
;
753 int count
= specpdl_ptr
- specpdl
;
754 Lisp_Object tem
, buf
;
757 buf
= Fcurrent_buffer ();
759 buf
= Fget_buffer (bufname
);
761 error ("No such buffer.");
763 if (NILP (printflag
))
767 specbind (Qstandard_output
, tem
);
768 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
769 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
770 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
771 unbind_to (count
, Qnil
);
777 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
778 "Execute the current buffer as Lisp code.\n\
779 Programs can pass argument PRINTFLAG which controls printing of output:\n\
780 nil means discard it; anything else is stream for print.\n\
782 If there is no error, point does not move. If there is an error,\n\
783 point remains at the end of the last character read from the buffer.")
785 Lisp_Object printflag
;
787 int count
= specpdl_ptr
- specpdl
;
788 Lisp_Object tem
, cbuf
;
790 cbuf
= Fcurrent_buffer ()
792 if (NILP (printflag
))
796 specbind (Qstandard_output
, tem
);
797 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
799 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
800 return unbind_to (count
, Qnil
);
804 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
805 "Execute the region as Lisp code.\n\
806 When called from programs, expects two arguments,\n\
807 giving starting and ending indices in the current buffer\n\
808 of the text to be executed.\n\
809 Programs can pass third argument PRINTFLAG which controls output:\n\
810 nil means discard it; anything else is stream for printing it.\n\
812 If there is no error, point does not move. If there is an error,\n\
813 point remains at the end of the last character read from the buffer.")
815 Lisp_Object b
, e
, printflag
;
817 int count
= specpdl_ptr
- specpdl
;
818 Lisp_Object tem
, cbuf
;
820 cbuf
= Fcurrent_buffer ();
822 if (NILP (printflag
))
826 specbind (Qstandard_output
, tem
);
828 if (NILP (printflag
))
829 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
830 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
832 /* This both uses b and checks its type. */
834 Fnarrow_to_region (make_number (BEGV
), e
);
835 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
837 return unbind_to (count
, Qnil
);
840 #endif /* standalone */
842 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
843 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
844 If STREAM is nil, use the value of `standard-input' (which see).\n\
845 STREAM or the value of `standard-input' may be:\n\
846 a buffer (read from point and advance it)\n\
847 a marker (read from where it points and advance it)\n\
848 a function (call it with no arguments for each character,\n\
849 call it with a char as argument to push a char back)\n\
850 a string (takes text from string, starting at the beginning)\n\
851 t (read text line using minibuffer and use it).")
853 Lisp_Object readcharfun
;
855 extern Lisp_Object
Fread_minibuffer ();
857 if (NILP (readcharfun
))
858 readcharfun
= Vstandard_input
;
859 if (EQ (readcharfun
, Qt
))
860 readcharfun
= Qread_char
;
863 if (EQ (readcharfun
, Qread_char
))
864 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
867 if (XTYPE (readcharfun
) == Lisp_String
)
868 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
870 return read0 (readcharfun
);
873 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
874 "Read one Lisp expression which is represented as text by STRING.\n\
875 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
876 START and END optionally delimit a substring of STRING from which to read;\n\
877 they default to 0 and (length STRING) respectively.")
879 Lisp_Object string
, start
, end
;
881 int startval
, endval
;
884 CHECK_STRING (string
,0);
887 endval
= XSTRING (string
)->size
;
889 { CHECK_NUMBER (end
,2);
891 if (endval
< 0 || endval
> XSTRING (string
)->size
)
892 args_out_of_range (string
, end
);
898 { CHECK_NUMBER (start
,1);
899 startval
= XINT (start
);
900 if (startval
< 0 || startval
> endval
)
901 args_out_of_range (string
, start
);
904 read_from_string_index
= startval
;
905 read_from_string_limit
= endval
;
907 tem
= read0 (string
);
908 return Fcons (tem
, make_number (read_from_string_index
));
911 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
915 Lisp_Object readcharfun
;
917 register Lisp_Object val
;
920 val
= read1 (readcharfun
);
921 if (XTYPE (val
) == Lisp_Internal
)
924 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
930 static int read_buffer_size
;
931 static char *read_buffer
;
934 read_escape (readcharfun
)
935 Lisp_Object readcharfun
;
937 register int c
= READCHAR
;
964 error ("Invalid escape character syntax");
967 c
= read_escape (readcharfun
);
968 return c
| meta_modifier
;
973 error ("Invalid escape character syntax");
976 c
= read_escape (readcharfun
);
977 return c
| shift_modifier
;
982 error ("Invalid escape character syntax");
985 c
= read_escape (readcharfun
);
986 return c
| hyper_modifier
;
991 error ("Invalid escape character syntax");
994 c
= read_escape (readcharfun
);
995 return c
| alt_modifier
;
1000 error ("Invalid escape character syntax");
1003 c
= read_escape (readcharfun
);
1004 return c
| super_modifier
;
1009 error ("Invalid escape character syntax");
1013 c
= read_escape (readcharfun
);
1014 if ((c
& 0177) == '?')
1016 /* ASCII control chars are made from letters (both cases),
1017 as well as the non-letters within 0100...0137. */
1018 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1019 return (c
& (037 | ~0177));
1020 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1021 return (c
& (037 | ~0177));
1023 return c
| ctrl_modifier
;
1033 /* An octal escape, as in ANSI C. */
1035 register int i
= c
- '0';
1036 register int count
= 0;
1039 if ((c
= READCHAR
) >= '0' && c
<= '7')
1054 /* A hex escape, as in ANSI C. */
1060 if (c
>= '0' && c
<= '9')
1065 else if ((c
>= 'a' && c
<= 'f')
1066 || (c
>= 'A' && c
<= 'F'))
1069 if (c
>= 'a' && c
<= 'f')
1090 register Lisp_Object readcharfun
;
1097 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1102 return read_list (0, readcharfun
);
1105 return read_vector (readcharfun
);
1110 register Lisp_Object val
;
1111 XSET (val
, Lisp_Internal
, c
);
1119 /* Accept compiled functions at read-time so that we don't have to
1120 build them using function calls. */
1122 tmp
= read_vector (readcharfun
);
1123 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1124 XVECTOR (tmp
)->contents
);
1126 #ifdef USE_TEXT_PROPERTIES
1130 struct gcpro gcpro1
;
1132 /* Read the string itself. */
1133 tmp
= read1 (readcharfun
);
1134 if (XTYPE (tmp
) != Lisp_String
)
1135 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1137 /* Read the intervals and their properties. */
1140 Lisp_Object beg
, end
, plist
;
1142 beg
= read1 (readcharfun
);
1143 if (XTYPE (beg
) == Lisp_Internal
)
1145 if (XINT (beg
) == ')')
1147 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1149 end
= read1 (readcharfun
);
1150 if (XTYPE (end
) == Lisp_Internal
)
1151 Fsignal (Qinvalid_read_syntax
,
1152 Fcons (make_string ("invalid string property list", 28), Qnil
));
1154 plist
= read1 (readcharfun
);
1155 if (XTYPE (plist
) == Lisp_Internal
)
1156 Fsignal (Qinvalid_read_syntax
,
1157 Fcons (make_string ("invalid string property list", 28), Qnil
));
1158 Fset_text_properties (beg
, end
, plist
, tmp
);
1165 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1168 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1173 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1178 register Lisp_Object val
;
1181 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1184 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1186 XSET (val
, Lisp_Int
, c
);
1193 register char *p
= read_buffer
;
1194 register char *end
= read_buffer
+ read_buffer_size
;
1198 while ((c
= READCHAR
) >= 0
1203 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1204 p
+= new - read_buffer
;
1205 read_buffer
+= new - read_buffer
;
1206 end
= read_buffer
+ read_buffer_size
;
1209 c
= read_escape (readcharfun
);
1210 /* c is -1 if \ newline has just been seen */
1213 if (p
== read_buffer
)
1218 /* Allow `\C- ' and `\C-?'. */
1219 if (c
== (CHAR_CTL
| ' '))
1221 else if (c
== (CHAR_CTL
| '?'))
1225 /* Move the meta bit to the right place for a string. */
1226 c
= (c
& ~CHAR_META
) | 0x80;
1228 error ("Invalid modifier in string");
1232 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1234 /* If purifying, and string starts with \ newline,
1235 return zero instead. This is for doc strings
1236 that we are really going to find in etc/DOC.nn.nn */
1237 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1238 return make_number (0);
1241 return make_pure_string (read_buffer
, p
- read_buffer
);
1243 return make_string (read_buffer
, p
- read_buffer
);
1248 #ifdef LISP_FLOAT_TYPE
1249 /* If a period is followed by a number, then we should read it
1250 as a floating point number. Otherwise, it denotes a dotted
1252 int next_char
= READCHAR
;
1255 if (! isdigit (next_char
))
1258 register Lisp_Object val
;
1259 XSET (val
, Lisp_Internal
, c
);
1263 /* Otherwise, we fall through! Note that the atom-reading loop
1264 below will now loop at least once, assuring that we will not
1265 try to UNREAD two characters in a row. */
1268 if (c
<= 040) goto retry
;
1270 register char *p
= read_buffer
;
1274 register char *end
= read_buffer
+ read_buffer_size
;
1277 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1278 || c
== '(' || c
== ')'
1279 #ifndef LISP_FLOAT_TYPE
1280 /* If we have floating-point support, then we need
1281 to allow <digits><dot><digits>. */
1283 #endif /* not LISP_FLOAT_TYPE */
1284 || c
== '[' || c
== ']' || c
== '#'
1289 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1290 p
+= new - read_buffer
;
1291 read_buffer
+= new - read_buffer
;
1292 end
= read_buffer
+ read_buffer_size
;
1305 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1306 p
+= new - read_buffer
;
1307 read_buffer
+= new - read_buffer
;
1308 /* end = read_buffer + read_buffer_size; */
1318 register Lisp_Object val
;
1320 if (*p1
== '+' || *p1
== '-') p1
++;
1321 /* Is it an integer? */
1324 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1325 #ifdef LISP_FLOAT_TYPE
1326 /* Integers can have trailing decimal points. */
1327 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1330 /* It is an integer. */
1332 #ifdef LISP_FLOAT_TYPE
1336 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1340 #ifdef LISP_FLOAT_TYPE
1341 if (isfloat_string (read_buffer
))
1342 return make_float (atof (read_buffer
));
1346 return intern (read_buffer
);
1351 #ifdef LISP_FLOAT_TYPE
1366 if (*cp
== '+' || *cp
== '-')
1372 while (isdigit (*cp
))
1383 while (isdigit (*cp
))
1391 if ((*cp
== '+') || (*cp
== '-'))
1397 while (isdigit (*cp
))
1401 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1402 || state
== (DOT_CHAR
|TRAIL_INT
)
1403 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1404 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1405 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1407 #endif /* LISP_FLOAT_TYPE */
1410 read_vector (readcharfun
)
1411 Lisp_Object readcharfun
;
1415 register Lisp_Object
*ptr
;
1416 register Lisp_Object tem
, vector
;
1417 register struct Lisp_Cons
*otem
;
1420 tem
= read_list (1, readcharfun
);
1421 len
= Flength (tem
);
1422 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1425 size
= XVECTOR (vector
)->size
;
1426 ptr
= XVECTOR (vector
)->contents
;
1427 for (i
= 0; i
< size
; i
++)
1429 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1437 /* flag = 1 means check for ] to terminate rather than ) and .
1438 flag = -1 means check for starting with defun
1439 and make structure pure. */
1442 read_list (flag
, readcharfun
)
1444 register Lisp_Object readcharfun
;
1446 /* -1 means check next element for defun,
1447 0 means don't check,
1448 1 means already checked and found defun. */
1449 int defunflag
= flag
< 0 ? -1 : 0;
1450 Lisp_Object val
, tail
;
1451 register Lisp_Object elt
, tem
;
1452 struct gcpro gcpro1
, gcpro2
;
1460 elt
= read1 (readcharfun
);
1462 if (XTYPE (elt
) == Lisp_Internal
)
1466 if (XINT (elt
) == ']')
1468 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1470 if (XINT (elt
) == ')')
1472 if (XINT (elt
) == '.')
1476 XCONS (tail
)->cdr
= read0 (readcharfun
);
1478 val
= read0 (readcharfun
);
1479 elt
= read1 (readcharfun
);
1481 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1483 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1485 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1487 tem
= (read_pure
&& flag
<= 0
1488 ? pure_cons (elt
, Qnil
)
1489 : Fcons (elt
, Qnil
));
1491 XCONS (tail
)->cdr
= tem
;
1496 defunflag
= EQ (elt
, Qdefun
);
1497 else if (defunflag
> 0)
1502 Lisp_Object Vobarray
;
1503 Lisp_Object initial_obarray
;
1506 check_obarray (obarray
)
1507 Lisp_Object obarray
;
1509 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1511 /* If Vobarray is now invalid, force it to be valid. */
1512 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1514 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1519 static int hash_string ();
1520 Lisp_Object
oblookup ();
1527 int len
= strlen (str
);
1528 Lisp_Object obarray
;
1531 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1532 obarray
= check_obarray (obarray
);
1533 tem
= oblookup (obarray
, str
, len
);
1534 if (XTYPE (tem
) == Lisp_Symbol
)
1536 return Fintern ((!NILP (Vpurify_flag
)
1537 ? make_pure_string (str
, len
)
1538 : make_string (str
, len
)),
1542 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1543 "Return the canonical symbol whose name is STRING.\n\
1544 If there is none, one is created by this function and returned.\n\
1545 A second optional argument specifies the obarray to use;\n\
1546 it defaults to the value of `obarray'.")
1548 Lisp_Object str
, obarray
;
1550 register Lisp_Object tem
, sym
, *ptr
;
1552 if (NILP (obarray
)) obarray
= Vobarray
;
1553 obarray
= check_obarray (obarray
);
1555 CHECK_STRING (str
, 0);
1557 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1558 if (XTYPE (tem
) != Lisp_Int
)
1561 if (!NILP (Vpurify_flag
))
1562 str
= Fpurecopy (str
);
1563 sym
= Fmake_symbol (str
);
1565 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1566 if (XTYPE (*ptr
) == Lisp_Symbol
)
1567 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1569 XSYMBOL (sym
)->next
= 0;
1574 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1575 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1576 A second optional argument specifies the obarray to use;\n\
1577 it defaults to the value of `obarray'.")
1579 Lisp_Object str
, obarray
;
1581 register Lisp_Object tem
;
1583 if (NILP (obarray
)) obarray
= Vobarray
;
1584 obarray
= check_obarray (obarray
);
1586 CHECK_STRING (str
, 0);
1588 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1589 if (XTYPE (tem
) != Lisp_Int
)
1595 oblookup (obarray
, ptr
, size
)
1596 Lisp_Object obarray
;
1601 register Lisp_Object tail
;
1602 Lisp_Object bucket
, tem
;
1604 if (XTYPE (obarray
) != Lisp_Vector
1605 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1607 obarray
= check_obarray (obarray
);
1608 obsize
= XVECTOR (obarray
)->size
;
1610 /* Combining next two lines breaks VMS C 2.3. */
1611 hash
= hash_string (ptr
, size
);
1613 bucket
= XVECTOR (obarray
)->contents
[hash
];
1614 if (XFASTINT (bucket
) == 0)
1616 else if (XTYPE (bucket
) != Lisp_Symbol
)
1617 error ("Bad data in guts of obarray"); /* Like CADR error message */
1618 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1620 if (XSYMBOL (tail
)->name
->size
== size
&&
1621 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1623 else if (XSYMBOL (tail
)->next
== 0)
1626 XSET (tem
, Lisp_Int
, hash
);
1631 hash_string (ptr
, len
)
1635 register unsigned char *p
= ptr
;
1636 register unsigned char *end
= p
+ len
;
1637 register unsigned char c
;
1638 register int hash
= 0;
1643 if (c
>= 0140) c
-= 40;
1644 hash
= ((hash
<<3) + (hash
>>28) + c
);
1646 return hash
& 07777777777;
1650 map_obarray (obarray
, fn
, arg
)
1651 Lisp_Object obarray
;
1656 register Lisp_Object tail
;
1657 CHECK_VECTOR (obarray
, 1);
1658 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1660 tail
= XVECTOR (obarray
)->contents
[i
];
1661 if (XFASTINT (tail
) != 0)
1665 if (XSYMBOL (tail
)->next
== 0)
1667 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1672 mapatoms_1 (sym
, function
)
1673 Lisp_Object sym
, function
;
1675 call1 (function
, sym
);
1678 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1679 "Call FUNCTION on every symbol in OBARRAY.\n\
1680 OBARRAY defaults to the value of `obarray'.")
1682 Lisp_Object function
, obarray
;
1686 if (NILP (obarray
)) obarray
= Vobarray
;
1687 obarray
= check_obarray (obarray
);
1689 map_obarray (obarray
, mapatoms_1
, function
);
1693 #define OBARRAY_SIZE 1511
1698 Lisp_Object oblength
;
1702 XFASTINT (oblength
) = OBARRAY_SIZE
;
1704 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1705 Vobarray
= Fmake_vector (oblength
, make_number (0));
1706 initial_obarray
= Vobarray
;
1707 staticpro (&initial_obarray
);
1708 /* Intern nil in the obarray */
1709 /* These locals are to kludge around a pyramid compiler bug. */
1710 hash
= hash_string ("nil", 3);
1711 /* Separate statement here to avoid VAXC bug. */
1712 hash
%= OBARRAY_SIZE
;
1713 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1716 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1717 XSYMBOL (Qnil
)->function
= Qunbound
;
1718 XSYMBOL (Qunbound
)->value
= Qunbound
;
1719 XSYMBOL (Qunbound
)->function
= Qunbound
;
1722 XSYMBOL (Qnil
)->value
= Qnil
;
1723 XSYMBOL (Qnil
)->plist
= Qnil
;
1724 XSYMBOL (Qt
)->value
= Qt
;
1726 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1729 Qvariable_documentation
= intern ("variable-documentation");
1731 read_buffer_size
= 100;
1732 read_buffer
= (char *) malloc (read_buffer_size
);
1737 struct Lisp_Subr
*sname
;
1740 sym
= intern (sname
->symbol_name
);
1741 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1744 #ifdef NOTDEF /* use fset in subr.el now */
1746 defalias (sname
, string
)
1747 struct Lisp_Subr
*sname
;
1751 sym
= intern (string
);
1752 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1756 /* Define an "integer variable"; a symbol whose value is forwarded
1757 to a C variable of type int. Sample call: */
1758 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1761 defvar_int (namestring
, address
)
1766 sym
= intern (namestring
);
1767 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1770 /* Similar but define a variable whose value is T if address contains 1,
1771 NIL if address contains 0 */
1774 defvar_bool (namestring
, address
)
1779 sym
= intern (namestring
);
1780 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1783 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1786 defvar_lisp (namestring
, address
)
1788 Lisp_Object
*address
;
1791 sym
= intern (namestring
);
1792 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1793 staticpro (address
);
1796 /* Similar but don't request gc-marking of the C variable.
1797 Used when that variable will be gc-marked for some other reason,
1798 since marking the same slot twice can cause trouble with strings. */
1801 defvar_lisp_nopro (namestring
, address
)
1803 Lisp_Object
*address
;
1806 sym
= intern (namestring
);
1807 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1812 /* Similar but define a variable whose value is the Lisp Object stored in
1813 the current buffer. address is the address of the slot in the buffer that is current now. */
1816 defvar_per_buffer (namestring
, address
, type
, doc
)
1818 Lisp_Object
*address
;
1824 extern struct buffer buffer_local_symbols
;
1826 sym
= intern (namestring
);
1827 offset
= (char *)address
- (char *)current_buffer
;
1829 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1830 (Lisp_Object
*) offset
);
1831 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1832 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1833 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1834 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1835 slot of buffer_local_flags */
1839 #endif /* standalone */
1845 /* Compute the default load-path. */
1847 normal
= PATH_LOADSEARCH
;
1848 Vload_path
= decode_env_path (0, normal
);
1850 if (NILP (Vpurify_flag
))
1851 normal
= PATH_LOADSEARCH
;
1853 normal
= PATH_DUMPLOADSEARCH
;
1855 /* In a dumped Emacs, we normally have to reset the value of
1856 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1857 uses ../lisp, instead of the path of the installed elisp
1858 libraries. However, if it appears that Vload_path was changed
1859 from the default before dumping, don't override that value. */
1862 Lisp_Object dump_path
;
1864 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1865 if (! NILP (Fequal (dump_path
, Vload_path
)))
1867 Vload_path
= decode_env_path (0, normal
);
1868 if (!NILP (Vinstallation_directory
))
1870 /* Add to the path the lisp subdir of the
1871 installation dir, if it exists. */
1872 Lisp_Object tem
, tem1
;
1873 tem
= Fexpand_file_name (build_string ("lisp"),
1874 Vinstallation_directory
);
1875 tem1
= Ffile_exists_p (tem
);
1878 if (NILP (Fmember (tem
, Vload_path
)))
1879 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1882 /* That dir doesn't exist, so add the build-time
1883 Lisp dirs instead. */
1884 Vload_path
= nconc2 (Vload_path
, dump_path
);
1889 Vload_path
= decode_env_path (0, normal
);
1892 /* Warn if dirs in the *standard* path don't exist. */
1894 Lisp_Object path_tail
;
1896 for (path_tail
= Vload_path
;
1898 path_tail
= XCONS (path_tail
)->cdr
)
1900 Lisp_Object dirfile
;
1901 dirfile
= Fcar (path_tail
);
1902 if (XTYPE (dirfile
) == Lisp_String
)
1904 dirfile
= Fdirectory_file_name (dirfile
);
1905 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1907 "Warning: Lisp directory `%s' does not exist.\n",
1908 XSTRING (Fcar (path_tail
))->data
);
1913 /* If the EMACSLOADPATH environment variable is set, use its value.
1914 This doesn't apply if we're dumping. */
1915 if (NILP (Vpurify_flag
)
1916 && egetenv ("EMACSLOADPATH"))
1917 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1921 load_in_progress
= 0;
1923 load_descriptor_list
= Qnil
;
1930 defsubr (&Sread_from_string
);
1932 defsubr (&Sintern_soft
);
1934 defsubr (&Seval_buffer
);
1935 defsubr (&Seval_region
);
1936 defsubr (&Sread_char
);
1937 defsubr (&Sread_char_exclusive
);
1938 defsubr (&Sread_event
);
1939 defsubr (&Sget_file_char
);
1940 defsubr (&Smapatoms
);
1942 DEFVAR_LISP ("obarray", &Vobarray
,
1943 "Symbol table for use by `intern' and `read'.\n\
1944 It is a vector whose length ought to be prime for best results.\n\
1945 The vector's contents don't make sense if examined from Lisp programs;\n\
1946 to find all the symbols in an obarray, use `mapatoms'.");
1948 DEFVAR_LISP ("values", &Vvalues
,
1949 "List of values of all expressions which were read, evaluated and printed.\n\
1950 Order is reverse chronological.");
1952 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1953 "Stream for read to get input from.\n\
1954 See documentation of `read' for possible values.");
1955 Vstandard_input
= Qt
;
1957 DEFVAR_LISP ("load-path", &Vload_path
,
1958 "*List of directories to search for files to load.\n\
1959 Each element is a string (directory name) or nil (try default directory).\n\
1960 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1961 otherwise to default specified by file `paths.h' when Emacs was built.");
1963 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1964 "Non-nil iff inside of `load'.");
1966 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1967 "An alist of expressions to be evalled when particular files are loaded.\n\
1968 Each element looks like (FILENAME FORMS...).\n\
1969 When `load' is run and the file-name argument is FILENAME,\n\
1970 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1971 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1972 with no directory specified, since that is how `load' is normally called.\n\
1973 An error in FORMS does not undo the load,\n\
1974 but does prevent execution of the rest of the FORMS.");
1975 Vafter_load_alist
= Qnil
;
1977 DEFVAR_LISP ("load-history", &Vload_history
,
1978 "Alist mapping source file names to symbols and features.\n\
1979 Each alist element is a list that starts with a file name,\n\
1980 except for one element (optional) that starts with nil and describes\n\
1981 definitions evaluated from buffers not visiting files.\n\
1982 The remaining elements of each list are symbols defined as functions\n\
1983 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1984 Vload_history
= Qnil
;
1986 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1987 "Used for internal purposes by `load'.");
1988 Vcurrent_load_list
= Qnil
;
1990 load_descriptor_list
= Qnil
;
1991 staticpro (&load_descriptor_list
);
1993 Qcurrent_load_list
= intern ("current-load-list");
1994 staticpro (&Qcurrent_load_list
);
1996 Qstandard_input
= intern ("standard-input");
1997 staticpro (&Qstandard_input
);
1999 Qread_char
= intern ("read-char");
2000 staticpro (&Qread_char
);
2002 Qget_file_char
= intern ("get-file-char");
2003 staticpro (&Qget_file_char
);
2005 Qascii_character
= intern ("ascii-character");
2006 staticpro (&Qascii_character
);
2008 Qload
= intern ("load");