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 unread_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
);
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
)
1221 /* Move the meta bit to the right place for a string. */
1222 c
= (c
& ~CHAR_META
) | 0x80;
1224 error ("Invalid modifier in string");
1228 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1230 /* If purifying, and string starts with \ newline,
1231 return zero instead. This is for doc strings
1232 that we are really going to find in etc/DOC.nn.nn */
1233 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1234 return make_number (0);
1237 return make_pure_string (read_buffer
, p
- read_buffer
);
1239 return make_string (read_buffer
, p
- read_buffer
);
1244 #ifdef LISP_FLOAT_TYPE
1245 /* If a period is followed by a number, then we should read it
1246 as a floating point number. Otherwise, it denotes a dotted
1248 int next_char
= READCHAR
;
1251 if (! isdigit (next_char
))
1254 register Lisp_Object val
;
1255 XSET (val
, Lisp_Internal
, c
);
1259 /* Otherwise, we fall through! Note that the atom-reading loop
1260 below will now loop at least once, assuring that we will not
1261 try to UNREAD two characters in a row. */
1264 if (c
<= 040) goto retry
;
1266 register char *p
= read_buffer
;
1270 register char *end
= read_buffer
+ read_buffer_size
;
1273 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1274 || c
== '(' || c
== ')'
1275 #ifndef LISP_FLOAT_TYPE
1276 /* If we have floating-point support, then we need
1277 to allow <digits><dot><digits>. */
1279 #endif /* not LISP_FLOAT_TYPE */
1280 || c
== '[' || c
== ']' || c
== '#'
1285 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1286 p
+= new - read_buffer
;
1287 read_buffer
+= new - read_buffer
;
1288 end
= read_buffer
+ read_buffer_size
;
1301 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1302 p
+= new - read_buffer
;
1303 read_buffer
+= new - read_buffer
;
1304 /* end = read_buffer + read_buffer_size; */
1314 register Lisp_Object val
;
1316 if (*p1
== '+' || *p1
== '-') p1
++;
1317 /* Is it an integer? */
1320 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1321 #ifdef LISP_FLOAT_TYPE
1322 /* Integers can have trailing decimal points. */
1323 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1326 /* It is an integer. */
1328 #ifdef LISP_FLOAT_TYPE
1332 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1336 #ifdef LISP_FLOAT_TYPE
1337 if (isfloat_string (read_buffer
))
1338 return make_float (atof (read_buffer
));
1342 return intern (read_buffer
);
1347 #ifdef LISP_FLOAT_TYPE
1362 if (*cp
== '+' || *cp
== '-')
1368 while (isdigit (*cp
))
1379 while (isdigit (*cp
))
1387 if ((*cp
== '+') || (*cp
== '-'))
1393 while (isdigit (*cp
))
1397 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1398 || state
== (DOT_CHAR
|TRAIL_INT
)
1399 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1400 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1401 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1403 #endif /* LISP_FLOAT_TYPE */
1406 read_vector (readcharfun
)
1407 Lisp_Object readcharfun
;
1411 register Lisp_Object
*ptr
;
1412 register Lisp_Object tem
, vector
;
1413 register struct Lisp_Cons
*otem
;
1416 tem
= read_list (1, readcharfun
);
1417 len
= Flength (tem
);
1418 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1421 size
= XVECTOR (vector
)->size
;
1422 ptr
= XVECTOR (vector
)->contents
;
1423 for (i
= 0; i
< size
; i
++)
1425 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1433 /* flag = 1 means check for ] to terminate rather than ) and .
1434 flag = -1 means check for starting with defun
1435 and make structure pure. */
1438 read_list (flag
, readcharfun
)
1440 register Lisp_Object readcharfun
;
1442 /* -1 means check next element for defun,
1443 0 means don't check,
1444 1 means already checked and found defun. */
1445 int defunflag
= flag
< 0 ? -1 : 0;
1446 Lisp_Object val
, tail
;
1447 register Lisp_Object elt
, tem
;
1448 struct gcpro gcpro1
, gcpro2
;
1456 elt
= read1 (readcharfun
);
1458 if (XTYPE (elt
) == Lisp_Internal
)
1462 if (XINT (elt
) == ']')
1464 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1466 if (XINT (elt
) == ')')
1468 if (XINT (elt
) == '.')
1472 XCONS (tail
)->cdr
= read0 (readcharfun
);
1474 val
= read0 (readcharfun
);
1475 elt
= read1 (readcharfun
);
1477 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1479 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1481 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1483 tem
= (read_pure
&& flag
<= 0
1484 ? pure_cons (elt
, Qnil
)
1485 : Fcons (elt
, Qnil
));
1487 XCONS (tail
)->cdr
= tem
;
1492 defunflag
= EQ (elt
, Qdefun
);
1493 else if (defunflag
> 0)
1498 Lisp_Object Vobarray
;
1499 Lisp_Object initial_obarray
;
1502 check_obarray (obarray
)
1503 Lisp_Object obarray
;
1505 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1507 /* If Vobarray is now invalid, force it to be valid. */
1508 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1510 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1515 static int hash_string ();
1516 Lisp_Object
oblookup ();
1523 int len
= strlen (str
);
1524 Lisp_Object obarray
;
1527 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1528 obarray
= check_obarray (obarray
);
1529 tem
= oblookup (obarray
, str
, len
);
1530 if (XTYPE (tem
) == Lisp_Symbol
)
1532 return Fintern ((!NILP (Vpurify_flag
)
1533 ? make_pure_string (str
, len
)
1534 : make_string (str
, len
)),
1538 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1539 "Return the canonical symbol whose name is STRING.\n\
1540 If there is none, one is created by this function and returned.\n\
1541 A second optional argument specifies the obarray to use;\n\
1542 it defaults to the value of `obarray'.")
1544 Lisp_Object str
, obarray
;
1546 register Lisp_Object tem
, sym
, *ptr
;
1548 if (NILP (obarray
)) obarray
= Vobarray
;
1549 obarray
= check_obarray (obarray
);
1551 CHECK_STRING (str
, 0);
1553 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1554 if (XTYPE (tem
) != Lisp_Int
)
1557 if (!NILP (Vpurify_flag
))
1558 str
= Fpurecopy (str
);
1559 sym
= Fmake_symbol (str
);
1561 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1562 if (XTYPE (*ptr
) == Lisp_Symbol
)
1563 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1565 XSYMBOL (sym
)->next
= 0;
1570 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1571 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1572 A second optional argument specifies the obarray to use;\n\
1573 it defaults to the value of `obarray'.")
1575 Lisp_Object str
, obarray
;
1577 register Lisp_Object tem
;
1579 if (NILP (obarray
)) obarray
= Vobarray
;
1580 obarray
= check_obarray (obarray
);
1582 CHECK_STRING (str
, 0);
1584 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1585 if (XTYPE (tem
) != Lisp_Int
)
1591 oblookup (obarray
, ptr
, size
)
1592 Lisp_Object obarray
;
1597 register Lisp_Object tail
;
1598 Lisp_Object bucket
, tem
;
1600 if (XTYPE (obarray
) != Lisp_Vector
1601 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1603 obarray
= check_obarray (obarray
);
1604 obsize
= XVECTOR (obarray
)->size
;
1606 /* Combining next two lines breaks VMS C 2.3. */
1607 hash
= hash_string (ptr
, size
);
1609 bucket
= XVECTOR (obarray
)->contents
[hash
];
1610 if (XFASTINT (bucket
) == 0)
1612 else if (XTYPE (bucket
) != Lisp_Symbol
)
1613 error ("Bad data in guts of obarray"); /* Like CADR error message */
1614 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1616 if (XSYMBOL (tail
)->name
->size
== size
&&
1617 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1619 else if (XSYMBOL (tail
)->next
== 0)
1622 XSET (tem
, Lisp_Int
, hash
);
1627 hash_string (ptr
, len
)
1631 register unsigned char *p
= ptr
;
1632 register unsigned char *end
= p
+ len
;
1633 register unsigned char c
;
1634 register int hash
= 0;
1639 if (c
>= 0140) c
-= 40;
1640 hash
= ((hash
<<3) + (hash
>>28) + c
);
1642 return hash
& 07777777777;
1646 map_obarray (obarray
, fn
, arg
)
1647 Lisp_Object obarray
;
1652 register Lisp_Object tail
;
1653 CHECK_VECTOR (obarray
, 1);
1654 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1656 tail
= XVECTOR (obarray
)->contents
[i
];
1657 if (XFASTINT (tail
) != 0)
1661 if (XSYMBOL (tail
)->next
== 0)
1663 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1668 mapatoms_1 (sym
, function
)
1669 Lisp_Object sym
, function
;
1671 call1 (function
, sym
);
1674 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1675 "Call FUNCTION on every symbol in OBARRAY.\n\
1676 OBARRAY defaults to the value of `obarray'.")
1678 Lisp_Object function
, obarray
;
1682 if (NILP (obarray
)) obarray
= Vobarray
;
1683 obarray
= check_obarray (obarray
);
1685 map_obarray (obarray
, mapatoms_1
, function
);
1689 #define OBARRAY_SIZE 1511
1694 Lisp_Object oblength
;
1698 XFASTINT (oblength
) = OBARRAY_SIZE
;
1700 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1701 Vobarray
= Fmake_vector (oblength
, make_number (0));
1702 initial_obarray
= Vobarray
;
1703 staticpro (&initial_obarray
);
1704 /* Intern nil in the obarray */
1705 /* These locals are to kludge around a pyramid compiler bug. */
1706 hash
= hash_string ("nil", 3);
1707 /* Separate statement here to avoid VAXC bug. */
1708 hash
%= OBARRAY_SIZE
;
1709 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1712 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1713 XSYMBOL (Qnil
)->function
= Qunbound
;
1714 XSYMBOL (Qunbound
)->value
= Qunbound
;
1715 XSYMBOL (Qunbound
)->function
= Qunbound
;
1718 XSYMBOL (Qnil
)->value
= Qnil
;
1719 XSYMBOL (Qnil
)->plist
= Qnil
;
1720 XSYMBOL (Qt
)->value
= Qt
;
1722 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1725 Qvariable_documentation
= intern ("variable-documentation");
1727 read_buffer_size
= 100;
1728 read_buffer
= (char *) malloc (read_buffer_size
);
1733 struct Lisp_Subr
*sname
;
1736 sym
= intern (sname
->symbol_name
);
1737 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1740 #ifdef NOTDEF /* use fset in subr.el now */
1742 defalias (sname
, string
)
1743 struct Lisp_Subr
*sname
;
1747 sym
= intern (string
);
1748 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1752 /* New replacement for DefIntVar; it ignores the doc string argument
1753 on the assumption that make-docfile will handle that. */
1754 /* Define an "integer variable"; a symbol whose value is forwarded
1755 to a C variable of type int. Sample call: */
1756 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1759 defvar_int (namestring
, address
, doc
)
1765 sym
= intern (namestring
);
1766 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1769 /* Similar but define a variable whose value is T if address contains 1,
1770 NIL if address contains 0 */
1773 defvar_bool (namestring
, address
, doc
)
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
, doc
)
1788 Lisp_Object
*address
;
1792 sym
= intern (namestring
);
1793 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1794 staticpro (address
);
1797 /* Similar but don't request gc-marking of the C variable.
1798 Used when that variable will be gc-marked for some other reason,
1799 since marking the same slot twice can cause trouble with strings. */
1802 defvar_lisp_nopro (namestring
, address
, doc
)
1804 Lisp_Object
*address
;
1808 sym
= intern (namestring
);
1809 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1814 /* Similar but define a variable whose value is the Lisp Object stored in
1815 the current buffer. address is the address of the slot in the buffer that is current now. */
1818 defvar_per_buffer (namestring
, address
, type
, doc
)
1820 Lisp_Object
*address
;
1826 extern struct buffer buffer_local_symbols
;
1828 sym
= intern (namestring
);
1829 offset
= (char *)address
- (char *)current_buffer
;
1831 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1832 (Lisp_Object
*) offset
);
1833 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1834 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1835 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1836 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1837 slot of buffer_local_flags */
1841 #endif /* standalone */
1847 /* Compute the default load-path. */
1849 normal
= PATH_LOADSEARCH
;
1850 Vload_path
= decode_env_path (0, normal
);
1852 if (NILP (Vpurify_flag
))
1853 normal
= PATH_LOADSEARCH
;
1855 normal
= PATH_DUMPLOADSEARCH
;
1857 /* In a dumped Emacs, we normally have to reset the value of
1858 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1859 uses ../lisp, instead of the path of the installed elisp
1860 libraries. However, if it appears that Vload_path was changed
1861 from the default before dumping, don't override that value. */
1864 Lisp_Object dump_path
;
1866 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1867 if (! NILP (Fequal (dump_path
, Vload_path
)))
1869 Vload_path
= decode_env_path (0, normal
);
1870 if (!NILP (Vinstallation_directory
))
1872 /* Add to the path the lisp subdir of the
1873 installation dir, if it exists. */
1874 Lisp_Object tem
, tem1
;
1875 tem
= Fexpand_file_name (build_string ("lisp"),
1876 Vinstallation_directory
);
1877 tem1
= Ffile_exists_p (tem
);
1880 if (NILP (Fmember (tem
, Vload_path
)))
1881 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1884 /* That dir doesn't exist, so add the build-time
1885 Lisp dirs instead. */
1886 Vload_path
= nconc2 (Vload_path
, dump_path
);
1891 Vload_path
= decode_env_path (0, normal
);
1894 /* Warn if dirs in the *standard* path don't exist. */
1896 Lisp_Object path_tail
;
1898 for (path_tail
= Vload_path
;
1900 path_tail
= XCONS (path_tail
)->cdr
)
1902 Lisp_Object dirfile
;
1903 dirfile
= Fcar (path_tail
);
1904 if (XTYPE (dirfile
) == Lisp_String
)
1906 dirfile
= Fdirectory_file_name (dirfile
);
1907 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1909 "Warning: Lisp directory `%s' does not exist.\n",
1910 XSTRING (Fcar (path_tail
))->data
);
1915 /* If the EMACSLOADPATH environment variable is set, use its value.
1916 This doesn't apply if we're dumping. */
1917 if (NILP (Vpurify_flag
)
1918 && egetenv ("EMACSLOADPATH"))
1919 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1923 load_in_progress
= 0;
1925 load_descriptor_list
= Qnil
;
1932 defsubr (&Sread_from_string
);
1934 defsubr (&Sintern_soft
);
1936 defsubr (&Seval_buffer
);
1937 defsubr (&Seval_region
);
1938 defsubr (&Sread_char
);
1939 defsubr (&Sread_char_exclusive
);
1940 defsubr (&Sread_event
);
1941 defsubr (&Sget_file_char
);
1942 defsubr (&Smapatoms
);
1944 DEFVAR_LISP ("obarray", &Vobarray
,
1945 "Symbol table for use by `intern' and `read'.\n\
1946 It is a vector whose length ought to be prime for best results.\n\
1947 The vector's contents don't make sense if examined from Lisp programs;\n\
1948 to find all the symbols in an obarray, use `mapatoms'.");
1950 DEFVAR_LISP ("values", &Vvalues
,
1951 "List of values of all expressions which were read, evaluated and printed.\n\
1952 Order is reverse chronological.");
1954 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1955 "Stream for read to get input from.\n\
1956 See documentation of `read' for possible values.");
1957 Vstandard_input
= Qt
;
1959 DEFVAR_LISP ("load-path", &Vload_path
,
1960 "*List of directories to search for files to load.\n\
1961 Each element is a string (directory name) or nil (try default directory).\n\
1962 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1963 otherwise to default specified by file `paths.h' when Emacs was built.");
1965 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1966 "Non-nil iff inside of `load'.");
1968 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1969 "An alist of expressions to be evalled when particular files are loaded.\n\
1970 Each element looks like (FILENAME FORMS...).\n\
1971 When `load' is run and the file-name argument is FILENAME,\n\
1972 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1973 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1974 with no directory specified, since that is how `load' is normally called.\n\
1975 An error in FORMS does not undo the load,\n\
1976 but does prevent execution of the rest of the FORMS.");
1977 Vafter_load_alist
= Qnil
;
1979 DEFVAR_LISP ("load-history", &Vload_history
,
1980 "Alist mapping source file names to symbols and features.\n\
1981 Each alist element is a list that starts with a file name,\n\
1982 except for one element (optional) that starts with nil and describes\n\
1983 definitions evaluated from buffers not visiting files.\n\
1984 The remaining elements of each list are symbols defined as functions\n\
1985 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1986 Vload_history
= Qnil
;
1988 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1989 "Used for internal purposes by `load'.");
1990 Vcurrent_load_list
= Qnil
;
1992 load_descriptor_list
= Qnil
;
1993 staticpro (&load_descriptor_list
);
1995 Qcurrent_load_list
= intern ("current-load-list");
1996 staticpro (&Qcurrent_load_list
);
1998 Qstandard_input
= intern ("standard-input");
1999 staticpro (&Qstandard_input
);
2001 Qread_char
= intern ("read-char");
2002 staticpro (&Qread_char
);
2004 Qget_file_char
= intern ("get-file-char");
2005 staticpro (&Qget_file_char
);
2007 Qascii_character
= intern ("ascii-character");
2008 staticpro (&Qascii_character
);
2010 Qload
= intern ("load");