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. */
23 #include <sys/types.h>
35 #include "termhooks.h"
39 #include <sys/inode.h>
46 #ifdef LISP_FLOAT_TYPE
52 /* These are redefined (correctly, but differently) in values.h. */
59 #endif /* LISP_FLOAT_TYPE */
61 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
62 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
63 Lisp_Object Qascii_character
, Qload
;
65 extern Lisp_Object Qevent_symbol_element_mask
;
67 /* non-zero if inside `load' */
70 /* Search path for files to be loaded. */
71 Lisp_Object Vload_path
;
73 /* This is the user-visible association list that maps features to
74 lists of defs in their load files. */
75 Lisp_Object Vload_history
;
77 /* This is useud to build the load history. */
78 Lisp_Object Vcurrent_load_list
;
80 /* List of descriptors now open for Fload. */
81 static Lisp_Object load_descriptor_list
;
83 /* File for get_file_char to read from. Use by load */
84 static FILE *instream
;
86 /* When nonzero, read conses in pure space */
89 /* For use within read-from-string (this reader is non-reentrant!!) */
90 static int read_from_string_index
;
91 static int read_from_string_limit
;
93 /* Handle unreading and rereading of characters.
94 Write READCHAR to read a character,
95 UNREAD(c) to unread c to be read again. */
97 #define READCHAR readchar (readcharfun)
98 #define UNREAD(c) unreadchar (readcharfun, c)
101 readchar (readcharfun
)
102 Lisp_Object readcharfun
;
105 register struct buffer
*inbuffer
;
106 register int c
, mpos
;
108 if (XTYPE (readcharfun
) == Lisp_Buffer
)
110 inbuffer
= XBUFFER (readcharfun
);
112 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
114 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
115 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
119 if (XTYPE (readcharfun
) == Lisp_Marker
)
121 inbuffer
= XMARKER (readcharfun
)->buffer
;
123 mpos
= marker_position (readcharfun
);
125 if (mpos
> BUF_ZV (inbuffer
) - 1)
127 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
128 if (mpos
!= BUF_GPT (inbuffer
))
129 XMARKER (readcharfun
)->bufpos
++;
131 Fset_marker (readcharfun
, make_number (mpos
+ 1),
132 Fmarker_buffer (readcharfun
));
135 if (EQ (readcharfun
, Qget_file_char
))
136 return getc (instream
);
138 if (XTYPE (readcharfun
) == Lisp_String
)
141 /* This used to be return of a conditional expression,
142 but that truncated -1 to a char on VMS. */
143 if (read_from_string_index
< read_from_string_limit
)
144 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
150 tem
= call0 (readcharfun
);
157 /* Unread the character C in the way appropriate for the stream READCHARFUN.
158 If the stream is a user function, call it with the char as argument. */
161 unreadchar (readcharfun
, c
)
162 Lisp_Object readcharfun
;
166 /* Don't back up the pointer if we're unreading the end-of-input mark,
167 since readchar didn't advance it when we read it. */
169 else if (XTYPE (readcharfun
) == Lisp_Buffer
)
171 if (XBUFFER (readcharfun
) == current_buffer
)
174 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
176 else if (XTYPE (readcharfun
) == Lisp_Marker
)
177 XMARKER (readcharfun
)->bufpos
--;
178 else if (XTYPE (readcharfun
) == Lisp_String
)
179 read_from_string_index
--;
180 else if (EQ (readcharfun
, Qget_file_char
))
181 ungetc (c
, instream
);
183 call1 (readcharfun
, make_number (c
));
186 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
188 /* get a character from the tty */
190 extern Lisp_Object
read_char ();
192 /* Read input events until we get one that's acceptable for our purposes.
194 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
195 until we get a character we like, and then stuffed into
198 If ASCII_REQUIRED is non-zero, we check function key events to see
199 if the unmodified version of the symbol has a Qascii_character
200 property, and use that character, if present.
202 If ERROR_NONASCII is non-zero, we signal an error if the input we
203 get isn't an ASCII character with modifiers. If it's zero but
204 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
207 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
208 int no_switch_frame
, ascii_required
, error_nonascii
;
211 return make_number (getchar ());
213 register Lisp_Object val
, delayed_switch_frame
;
215 delayed_switch_frame
= Qnil
;
217 /* Read until we get an acceptable event. */
219 val
= read_char (0, 0, 0, Qnil
, 0);
221 if (XTYPE (val
) == Lisp_Buffer
)
224 /* switch-frame events are put off until after the next ASCII
225 character. This is better than signalling an error just because
226 the last characters were typed to a separate minibuffer frame,
227 for example. Eventually, some code which can deal with
228 switch-frame events will read it and process it. */
230 && EVENT_HAS_PARAMETERS (val
)
231 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
233 delayed_switch_frame
= val
;
239 /* Convert certain symbols to their ASCII equivalents. */
240 if (XTYPE (val
) == Lisp_Symbol
)
242 Lisp_Object tem
, tem1
, tem2
;
243 tem
= Fget (val
, Qevent_symbol_element_mask
);
246 tem1
= Fget (Fcar (tem
), Qascii_character
);
247 /* Merge this symbol's modifier bits
248 with the ASCII equivalent of its basic code. */
250 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
254 /* If we don't have a character now, deal with it appropriately. */
255 if (XTYPE (val
) != Lisp_Int
)
259 Vunread_command_events
= Fcons (val
, Qnil
);
260 error ("Non-character input-event");
267 if (! NILP (delayed_switch_frame
))
268 unread_switch_frame
= delayed_switch_frame
;
274 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
275 "Read a character from the command input (keyboard or macro).\n\
276 It is returned as a number.\n\
277 If the user generates an event which is not a character (i.e. a mouse\n\
278 click or function key event), `read-char' signals an error. As an\n\
279 exception, switch-frame events are put off until non-ASCII events can\n\
281 If you want to read non-character events, or ignore them, call\n\
282 `read-event' or `read-char-exclusive' instead.")
285 return read_filtered_event (1, 1, 1);
288 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
289 "Read an event object from the input stream.")
292 return read_filtered_event (0, 0, 0);
295 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
296 "Read a character from the command input (keyboard or macro).\n\
297 It is returned as a number. Non character events are ignored.")
300 return read_filtered_event (1, 1, 0);
303 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
304 "Don't use this yourself.")
307 register Lisp_Object val
;
308 XSET (val
, Lisp_Int
, getc (instream
));
312 static void readevalloop ();
313 static Lisp_Object
load_unwind ();
314 static Lisp_Object
load_descriptor_unwind ();
316 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
317 "Execute a file of Lisp code named FILE.\n\
318 First try FILE with `.elc' appended, then try with `.el',\n\
319 then try FILE unmodified.\n\
320 This function searches the directories in `load-path'.\n\
321 If optional second arg NOERROR is non-nil,\n\
322 report no error if FILE doesn't exist.\n\
323 Print messages at start and end of loading unless\n\
324 optional third arg NOMESSAGE is non-nil.\n\
325 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
326 suffixes `.elc' or `.el' to the specified name FILE.\n\
327 Return t if file exists.")
328 (str
, noerror
, nomessage
, nosuffix
)
329 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
331 register FILE *stream
;
332 register int fd
= -1;
333 register Lisp_Object lispstream
;
335 int count
= specpdl_ptr
- specpdl
;
339 /* 1 means inhibit the message at the beginning. */
343 char *dosmode
= "rt";
346 CHECK_STRING (str
, 0);
347 str
= Fsubstitute_in_file_name (str
);
349 /* If file name is magic, call the handler. */
350 handler
= Ffind_file_name_handler (str
, Qload
);
352 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
354 /* Avoid weird lossage with null string as arg,
355 since it would try to load a directory as a Lisp file */
356 if (XSTRING (str
)->size
> 0)
359 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
368 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
374 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
383 stat ((char *)XSTRING (found
)->data
, &s1
);
384 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
385 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
386 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
388 message ("Source file `%s' newer than byte-compiled file",
389 XSTRING (found
)->data
);
390 /* Don't immediately overwrite this message. */
394 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
399 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
401 stream
= fdopen (fd
, "r");
406 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
409 if (NILP (nomessage
) && !nomessage1
)
410 message ("Loading %s...", XSTRING (str
)->data
);
413 /* We may not be able to store STREAM itself as a Lisp_Object pointer
414 since that is guaranteed to work only for data that has been malloc'd.
415 So malloc a full-size pointer, and record the address of that pointer. */
416 ptr
= (FILE **) xmalloc (sizeof (FILE *));
418 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
419 record_unwind_protect (load_unwind
, lispstream
);
420 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
422 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
424 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
425 unbind_to (count
, Qnil
);
427 /* Run any load-hooks for this file. */
428 temp
= Fassoc (str
, Vafter_load_alist
);
430 Fprogn (Fcdr (temp
));
433 if (!noninteractive
&& NILP (nomessage
))
434 message ("Loading %s...done", XSTRING (str
)->data
);
439 load_unwind (stream
) /* used as unwind-protect function in load */
442 fclose (*(FILE **) XSTRING (stream
));
443 xfree (XPNTR (stream
));
444 if (--load_in_progress
< 0) load_in_progress
= 0;
449 load_descriptor_unwind (oldlist
)
452 load_descriptor_list
= oldlist
;
455 /* Close all descriptors in use for Floads.
456 This is used when starting a subprocess. */
462 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
463 close (XFASTINT (XCONS (tail
)->car
));
467 complete_filename_p (pathname
)
468 Lisp_Object pathname
;
470 register unsigned char *s
= XSTRING (pathname
)->data
;
478 #ifdef MSDOS /* MW, May 1993 */
479 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
484 /* Search for a file whose name is STR, looking in directories
485 in the Lisp list PATH, and trying suffixes from SUFFIX.
486 SUFFIX is a string containing possible suffixes separated by colons.
487 On success, returns a file descriptor. On failure, returns -1.
489 EXEC_ONLY nonzero means don't open the files,
490 just look for one that is executable. In this case,
491 returns 1 on success.
493 If STOREPTR is nonzero, it points to a slot where the name of
494 the file actually found should be stored as a Lisp string.
495 Nil is stored there on failure. */
498 openp (path
, str
, suffix
, storeptr
, exec_only
)
499 Lisp_Object path
, str
;
501 Lisp_Object
*storeptr
;
507 register char *fn
= buf
;
510 register Lisp_Object filename
;
518 if (complete_filename_p (str
))
521 for (; !NILP (path
); path
= Fcdr (path
))
525 filename
= Fexpand_file_name (str
, Fcar (path
));
526 if (!complete_filename_p (filename
))
527 /* If there are non-absolute elts in PATH (eg ".") */
528 /* Of course, this could conceivably lose if luser sets
529 default-directory to be something non-absolute... */
531 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
532 if (!complete_filename_p (filename
))
533 /* Give up on this path element! */
537 /* Calculate maximum size of any filename made from
538 this path element/specified file name and any possible suffix. */
539 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
540 if (fn_size
< want_size
)
541 fn
= (char *) alloca (fn_size
= 100 + want_size
);
545 /* Loop over suffixes. */
548 char *esuffix
= (char *) index (nsuffix
, ':');
549 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
551 /* Concatenate path element/specified name with the suffix. */
552 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
553 fn
[XSTRING (filename
)->size
] = 0;
554 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
555 strncat (fn
, nsuffix
, lsuffix
);
557 /* Ignore file if it's a directory. */
558 if (stat (fn
, &st
) >= 0
559 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
561 /* Check that we can access or open it. */
563 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
565 fd
= open (fn
, 0, 0);
569 /* We succeeded; return this descriptor and filename. */
571 *storeptr
= build_string (fn
);
576 /* Advance to next suffix. */
579 nsuffix
+= lsuffix
+ 1;
589 /* Merge the list we've accumulated of globals from the current input source
590 into the load_history variable. The details depend on whether
591 the source has an associated file name or not. */
594 build_load_history (stream
, source
)
598 register Lisp_Object tail
, prev
, newelt
;
599 register Lisp_Object tem
, tem2
;
600 register int foundit
, loading
;
602 /* Don't bother recording anything for preloaded files. */
603 if (!NILP (Vpurify_flag
))
606 loading
= stream
|| !NARROWED
;
608 tail
= Vload_history
;
615 /* Find the feature's previous assoc list... */
616 if (!NILP (Fequal (source
, Fcar (tem
))))
620 /* If we're loading, remove it. */
624 Vload_history
= Fcdr (tail
);
626 Fsetcdr (prev
, Fcdr (tail
));
629 /* Otherwise, cons on new symbols that are not already members. */
632 tem2
= Vcurrent_load_list
;
636 newelt
= Fcar (tem2
);
638 if (NILP (Fmemq (newelt
, tem
)))
639 Fsetcar (tail
, Fcons (Fcar (tem
),
640 Fcons (newelt
, Fcdr (tem
))));
653 /* If we're loading, cons the new assoc onto the front of load-history,
654 the most-recently-loaded position. Also do this if we didn't find
655 an existing member for the current source. */
656 if (loading
|| !foundit
)
657 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
662 unreadpure () /* Used as unwind-protect function in readevalloop */
669 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
670 Lisp_Object readcharfun
;
672 Lisp_Object sourcename
;
673 Lisp_Object (*evalfun
) ();
677 register Lisp_Object val
;
678 int count
= specpdl_ptr
- specpdl
;
680 struct buffer
*b
= 0;
682 if (BUFFERP (readcharfun
))
683 b
= XBUFFER (readcharfun
);
684 else if (MARKERP (readcharfun
))
685 b
= XMARKER (readcharfun
)->buffer
;
687 specbind (Qstandard_input
, readcharfun
);
688 specbind (Qcurrent_load_list
, Qnil
);
692 LOADHIST_ATTACH (sourcename
);
696 if (b
!= 0 && NILP (b
->name
))
697 error ("Reading from killed buffer");
703 while ((c
= READCHAR
) != '\n' && c
!= -1);
707 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
709 if (!NILP (Vpurify_flag
) && c
== '(')
711 record_unwind_protect (unreadpure
, Qnil
);
712 val
= read_list (-1, readcharfun
);
713 unbind_to (count
+ 1, Qnil
);
718 val
= read0 (readcharfun
);
721 val
= (*evalfun
) (val
);
724 Vvalues
= Fcons (val
, Vvalues
);
725 if (EQ (Vstandard_output
, Qt
))
732 build_load_history (stream
, sourcename
);
735 unbind_to (count
, Qnil
);
740 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
741 "Execute the current buffer as Lisp code.\n\
742 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
743 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
744 PRINTFLAG controls printing of output:\n\
745 nil means discard it; anything else is stream for print.\n\
747 If there is no error, point does not move. If there is an error,\n\
748 point remains at the end of the last character read from the buffer.")
750 Lisp_Object bufname
, printflag
;
752 int count
= specpdl_ptr
- specpdl
;
753 Lisp_Object tem
, buf
;
756 buf
= Fcurrent_buffer ();
758 buf
= Fget_buffer (bufname
);
760 error ("No such buffer.");
762 if (NILP (printflag
))
766 specbind (Qstandard_output
, tem
);
767 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
768 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
769 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
770 unbind_to (count
, Qnil
);
776 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
777 "Execute the current buffer as Lisp code.\n\
778 Programs can pass argument PRINTFLAG which controls printing of output:\n\
779 nil means discard it; anything else is stream for print.\n\
781 If there is no error, point does not move. If there is an error,\n\
782 point remains at the end of the last character read from the buffer.")
784 Lisp_Object printflag
;
786 int count
= specpdl_ptr
- specpdl
;
787 Lisp_Object tem
, cbuf
;
789 cbuf
= Fcurrent_buffer ()
791 if (NILP (printflag
))
795 specbind (Qstandard_output
, tem
);
796 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
798 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
799 return unbind_to (count
, Qnil
);
803 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
804 "Execute the region as Lisp code.\n\
805 When called from programs, expects two arguments,\n\
806 giving starting and ending indices in the current buffer\n\
807 of the text to be executed.\n\
808 Programs can pass third argument PRINTFLAG which controls output:\n\
809 nil means discard it; anything else is stream for printing it.\n\
811 If there is no error, point does not move. If there is an error,\n\
812 point remains at the end of the last character read from the buffer.")
814 Lisp_Object b
, e
, printflag
;
816 int count
= specpdl_ptr
- specpdl
;
817 Lisp_Object tem
, cbuf
;
819 cbuf
= Fcurrent_buffer ();
821 if (NILP (printflag
))
825 specbind (Qstandard_output
, tem
);
827 if (NILP (printflag
))
828 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
829 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
831 /* This both uses b and checks its type. */
833 Fnarrow_to_region (make_number (BEGV
), e
);
834 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
836 return unbind_to (count
, Qnil
);
839 #endif /* standalone */
841 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
842 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
843 If STREAM is nil, use the value of `standard-input' (which see).\n\
844 STREAM or the value of `standard-input' may be:\n\
845 a buffer (read from point and advance it)\n\
846 a marker (read from where it points and advance it)\n\
847 a function (call it with no arguments for each character,\n\
848 call it with a char as argument to push a char back)\n\
849 a string (takes text from string, starting at the beginning)\n\
850 t (read text line using minibuffer and use it).")
852 Lisp_Object readcharfun
;
854 extern Lisp_Object
Fread_minibuffer ();
856 if (NILP (readcharfun
))
857 readcharfun
= Vstandard_input
;
858 if (EQ (readcharfun
, Qt
))
859 readcharfun
= Qread_char
;
862 if (EQ (readcharfun
, Qread_char
))
863 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
866 if (XTYPE (readcharfun
) == Lisp_String
)
867 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
869 return read0 (readcharfun
);
872 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
873 "Read one Lisp expression which is represented as text by STRING.\n\
874 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
875 START and END optionally delimit a substring of STRING from which to read;\n\
876 they default to 0 and (length STRING) respectively.")
878 Lisp_Object string
, start
, end
;
880 int startval
, endval
;
883 CHECK_STRING (string
,0);
886 endval
= XSTRING (string
)->size
;
888 { CHECK_NUMBER (end
,2);
890 if (endval
< 0 || endval
> XSTRING (string
)->size
)
891 args_out_of_range (string
, end
);
897 { CHECK_NUMBER (start
,1);
898 startval
= XINT (start
);
899 if (startval
< 0 || startval
> endval
)
900 args_out_of_range (string
, start
);
903 read_from_string_index
= startval
;
904 read_from_string_limit
= endval
;
906 tem
= read0 (string
);
907 return Fcons (tem
, make_number (read_from_string_index
));
910 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
914 Lisp_Object readcharfun
;
916 register Lisp_Object val
;
919 val
= read1 (readcharfun
);
920 if (XTYPE (val
) == Lisp_Internal
)
923 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
929 static int read_buffer_size
;
930 static char *read_buffer
;
933 read_escape (readcharfun
)
934 Lisp_Object readcharfun
;
936 register int c
= READCHAR
;
963 error ("Invalid escape character syntax");
966 c
= read_escape (readcharfun
);
967 return c
| meta_modifier
;
972 error ("Invalid escape character syntax");
975 c
= read_escape (readcharfun
);
976 return c
| shift_modifier
;
981 error ("Invalid escape character syntax");
984 c
= read_escape (readcharfun
);
985 return c
| hyper_modifier
;
990 error ("Invalid escape character syntax");
993 c
= read_escape (readcharfun
);
994 return c
| alt_modifier
;
999 error ("Invalid escape character syntax");
1002 c
= read_escape (readcharfun
);
1003 return c
| super_modifier
;
1008 error ("Invalid escape character syntax");
1012 c
= read_escape (readcharfun
);
1013 if ((c
& 0177) == '?')
1015 /* ASCII control chars are made from letters (both cases),
1016 as well as the non-letters within 0100...0137. */
1017 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1018 return (c
& (037 | ~0177));
1019 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1020 return (c
& (037 | ~0177));
1022 return c
| ctrl_modifier
;
1032 /* An octal escape, as in ANSI C. */
1034 register int i
= c
- '0';
1035 register int count
= 0;
1038 if ((c
= READCHAR
) >= '0' && c
<= '7')
1053 /* A hex escape, as in ANSI C. */
1059 if (c
>= '0' && c
<= '9')
1064 else if ((c
>= 'a' && c
<= 'f')
1065 || (c
>= 'A' && c
<= 'F'))
1068 if (c
>= 'a' && c
<= 'f')
1089 register Lisp_Object readcharfun
;
1096 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1101 return read_list (0, readcharfun
);
1104 return read_vector (readcharfun
);
1109 register Lisp_Object val
;
1110 XSET (val
, Lisp_Internal
, c
);
1118 /* Accept compiled functions at read-time so that we don't have to
1119 build them using function calls. */
1121 tmp
= read_vector (readcharfun
);
1122 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1123 XVECTOR (tmp
)->contents
);
1125 #ifdef USE_TEXT_PROPERTIES
1129 struct gcpro gcpro1
;
1131 /* Read the string itself. */
1132 tmp
= read1 (readcharfun
);
1133 if (XTYPE (tmp
) != Lisp_String
)
1134 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1136 /* Read the intervals and their properties. */
1139 Lisp_Object beg
, end
, plist
;
1141 beg
= read1 (readcharfun
);
1142 if (XTYPE (beg
) == Lisp_Internal
)
1144 if (XINT (beg
) == ')')
1146 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1148 end
= read1 (readcharfun
);
1149 if (XTYPE (end
) == Lisp_Internal
)
1150 Fsignal (Qinvalid_read_syntax
,
1151 Fcons (make_string ("invalid string property list", 28), Qnil
));
1153 plist
= read1 (readcharfun
);
1154 if (XTYPE (plist
) == Lisp_Internal
)
1155 Fsignal (Qinvalid_read_syntax
,
1156 Fcons (make_string ("invalid string property list", 28), Qnil
));
1157 Fset_text_properties (beg
, end
, plist
, tmp
);
1164 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1167 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1172 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1177 register Lisp_Object val
;
1180 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1183 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1185 XSET (val
, Lisp_Int
, c
);
1192 register char *p
= read_buffer
;
1193 register char *end
= read_buffer
+ read_buffer_size
;
1197 while ((c
= READCHAR
) >= 0
1202 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1203 p
+= new - read_buffer
;
1204 read_buffer
+= new - read_buffer
;
1205 end
= read_buffer
+ read_buffer_size
;
1208 c
= read_escape (readcharfun
);
1209 /* c is -1 if \ newline has just been seen */
1212 if (p
== read_buffer
)
1217 /* Allow `\C- ' and `\C-?'. */
1218 if (c
== (CHAR_CTL
| ' '))
1220 else if (c
== (CHAR_CTL
| '?'))
1224 /* Move the meta bit to the right place for a string. */
1225 c
= (c
& ~CHAR_META
) | 0x80;
1227 error ("Invalid modifier in string");
1231 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1233 /* If purifying, and string starts with \ newline,
1234 return zero instead. This is for doc strings
1235 that we are really going to find in etc/DOC.nn.nn */
1236 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1237 return make_number (0);
1240 return make_pure_string (read_buffer
, p
- read_buffer
);
1242 return make_string (read_buffer
, p
- read_buffer
);
1247 #ifdef LISP_FLOAT_TYPE
1248 /* If a period is followed by a number, then we should read it
1249 as a floating point number. Otherwise, it denotes a dotted
1251 int next_char
= READCHAR
;
1254 if (! isdigit (next_char
))
1257 register Lisp_Object val
;
1258 XSET (val
, Lisp_Internal
, c
);
1262 /* Otherwise, we fall through! Note that the atom-reading loop
1263 below will now loop at least once, assuring that we will not
1264 try to UNREAD two characters in a row. */
1267 if (c
<= 040) goto retry
;
1269 register char *p
= read_buffer
;
1273 register char *end
= read_buffer
+ read_buffer_size
;
1276 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1277 || c
== '(' || c
== ')'
1278 #ifndef LISP_FLOAT_TYPE
1279 /* If we have floating-point support, then we need
1280 to allow <digits><dot><digits>. */
1282 #endif /* not LISP_FLOAT_TYPE */
1283 || c
== '[' || c
== ']' || c
== '#'
1288 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1289 p
+= new - read_buffer
;
1290 read_buffer
+= new - read_buffer
;
1291 end
= read_buffer
+ read_buffer_size
;
1304 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1305 p
+= new - read_buffer
;
1306 read_buffer
+= new - read_buffer
;
1307 /* end = read_buffer + read_buffer_size; */
1317 register Lisp_Object val
;
1319 if (*p1
== '+' || *p1
== '-') p1
++;
1320 /* Is it an integer? */
1323 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1324 #ifdef LISP_FLOAT_TYPE
1325 /* Integers can have trailing decimal points. */
1326 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1329 /* It is an integer. */
1331 #ifdef LISP_FLOAT_TYPE
1335 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1339 #ifdef LISP_FLOAT_TYPE
1340 if (isfloat_string (read_buffer
))
1341 return make_float (atof (read_buffer
));
1345 return intern (read_buffer
);
1350 #ifdef LISP_FLOAT_TYPE
1365 if (*cp
== '+' || *cp
== '-')
1371 while (isdigit (*cp
))
1382 while (isdigit (*cp
))
1390 if ((*cp
== '+') || (*cp
== '-'))
1396 while (isdigit (*cp
))
1400 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1401 || state
== (DOT_CHAR
|TRAIL_INT
)
1402 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1403 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1404 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1406 #endif /* LISP_FLOAT_TYPE */
1409 read_vector (readcharfun
)
1410 Lisp_Object readcharfun
;
1414 register Lisp_Object
*ptr
;
1415 register Lisp_Object tem
, vector
;
1416 register struct Lisp_Cons
*otem
;
1419 tem
= read_list (1, readcharfun
);
1420 len
= Flength (tem
);
1421 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1424 size
= XVECTOR (vector
)->size
;
1425 ptr
= XVECTOR (vector
)->contents
;
1426 for (i
= 0; i
< size
; i
++)
1428 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1436 /* flag = 1 means check for ] to terminate rather than ) and .
1437 flag = -1 means check for starting with defun
1438 and make structure pure. */
1441 read_list (flag
, readcharfun
)
1443 register Lisp_Object readcharfun
;
1445 /* -1 means check next element for defun,
1446 0 means don't check,
1447 1 means already checked and found defun. */
1448 int defunflag
= flag
< 0 ? -1 : 0;
1449 Lisp_Object val
, tail
;
1450 register Lisp_Object elt
, tem
;
1451 struct gcpro gcpro1
, gcpro2
;
1459 elt
= read1 (readcharfun
);
1461 if (XTYPE (elt
) == Lisp_Internal
)
1465 if (XINT (elt
) == ']')
1467 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1469 if (XINT (elt
) == ')')
1471 if (XINT (elt
) == '.')
1475 XCONS (tail
)->cdr
= read0 (readcharfun
);
1477 val
= read0 (readcharfun
);
1478 elt
= read1 (readcharfun
);
1480 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1482 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1484 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1486 tem
= (read_pure
&& flag
<= 0
1487 ? pure_cons (elt
, Qnil
)
1488 : Fcons (elt
, Qnil
));
1490 XCONS (tail
)->cdr
= tem
;
1495 defunflag
= EQ (elt
, Qdefun
);
1496 else if (defunflag
> 0)
1501 Lisp_Object Vobarray
;
1502 Lisp_Object initial_obarray
;
1505 check_obarray (obarray
)
1506 Lisp_Object obarray
;
1508 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1510 /* If Vobarray is now invalid, force it to be valid. */
1511 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1513 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1518 static int hash_string ();
1519 Lisp_Object
oblookup ();
1526 int len
= strlen (str
);
1527 Lisp_Object obarray
;
1530 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1531 obarray
= check_obarray (obarray
);
1532 tem
= oblookup (obarray
, str
, len
);
1533 if (XTYPE (tem
) == Lisp_Symbol
)
1535 return Fintern ((!NILP (Vpurify_flag
)
1536 ? make_pure_string (str
, len
)
1537 : make_string (str
, len
)),
1541 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1542 "Return the canonical symbol whose name is STRING.\n\
1543 If there is none, one is created by this function and returned.\n\
1544 A second optional argument specifies the obarray to use;\n\
1545 it defaults to the value of `obarray'.")
1547 Lisp_Object str
, obarray
;
1549 register Lisp_Object tem
, sym
, *ptr
;
1551 if (NILP (obarray
)) obarray
= Vobarray
;
1552 obarray
= check_obarray (obarray
);
1554 CHECK_STRING (str
, 0);
1556 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1557 if (XTYPE (tem
) != Lisp_Int
)
1560 if (!NILP (Vpurify_flag
))
1561 str
= Fpurecopy (str
);
1562 sym
= Fmake_symbol (str
);
1564 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1565 if (XTYPE (*ptr
) == Lisp_Symbol
)
1566 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1568 XSYMBOL (sym
)->next
= 0;
1573 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1574 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1575 A second optional argument specifies the obarray to use;\n\
1576 it defaults to the value of `obarray'.")
1578 Lisp_Object str
, obarray
;
1580 register Lisp_Object tem
;
1582 if (NILP (obarray
)) obarray
= Vobarray
;
1583 obarray
= check_obarray (obarray
);
1585 CHECK_STRING (str
, 0);
1587 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1588 if (XTYPE (tem
) != Lisp_Int
)
1594 oblookup (obarray
, ptr
, size
)
1595 Lisp_Object obarray
;
1600 register Lisp_Object tail
;
1601 Lisp_Object bucket
, tem
;
1603 if (XTYPE (obarray
) != Lisp_Vector
1604 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1606 obarray
= check_obarray (obarray
);
1607 obsize
= XVECTOR (obarray
)->size
;
1609 /* Combining next two lines breaks VMS C 2.3. */
1610 hash
= hash_string (ptr
, size
);
1612 bucket
= XVECTOR (obarray
)->contents
[hash
];
1613 if (XFASTINT (bucket
) == 0)
1615 else if (XTYPE (bucket
) != Lisp_Symbol
)
1616 error ("Bad data in guts of obarray"); /* Like CADR error message */
1617 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1619 if (XSYMBOL (tail
)->name
->size
== size
&&
1620 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1622 else if (XSYMBOL (tail
)->next
== 0)
1625 XSET (tem
, Lisp_Int
, hash
);
1630 hash_string (ptr
, len
)
1634 register unsigned char *p
= ptr
;
1635 register unsigned char *end
= p
+ len
;
1636 register unsigned char c
;
1637 register int hash
= 0;
1642 if (c
>= 0140) c
-= 40;
1643 hash
= ((hash
<<3) + (hash
>>28) + c
);
1645 return hash
& 07777777777;
1649 map_obarray (obarray
, fn
, arg
)
1650 Lisp_Object obarray
;
1655 register Lisp_Object tail
;
1656 CHECK_VECTOR (obarray
, 1);
1657 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1659 tail
= XVECTOR (obarray
)->contents
[i
];
1660 if (XFASTINT (tail
) != 0)
1664 if (XSYMBOL (tail
)->next
== 0)
1666 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1671 mapatoms_1 (sym
, function
)
1672 Lisp_Object sym
, function
;
1674 call1 (function
, sym
);
1677 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1678 "Call FUNCTION on every symbol in OBARRAY.\n\
1679 OBARRAY defaults to the value of `obarray'.")
1681 Lisp_Object function
, obarray
;
1685 if (NILP (obarray
)) obarray
= Vobarray
;
1686 obarray
= check_obarray (obarray
);
1688 map_obarray (obarray
, mapatoms_1
, function
);
1692 #define OBARRAY_SIZE 1511
1697 Lisp_Object oblength
;
1701 XFASTINT (oblength
) = OBARRAY_SIZE
;
1703 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1704 Vobarray
= Fmake_vector (oblength
, make_number (0));
1705 initial_obarray
= Vobarray
;
1706 staticpro (&initial_obarray
);
1707 /* Intern nil in the obarray */
1708 /* These locals are to kludge around a pyramid compiler bug. */
1709 hash
= hash_string ("nil", 3);
1710 /* Separate statement here to avoid VAXC bug. */
1711 hash
%= OBARRAY_SIZE
;
1712 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1715 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1716 XSYMBOL (Qnil
)->function
= Qunbound
;
1717 XSYMBOL (Qunbound
)->value
= Qunbound
;
1718 XSYMBOL (Qunbound
)->function
= Qunbound
;
1721 XSYMBOL (Qnil
)->value
= Qnil
;
1722 XSYMBOL (Qnil
)->plist
= Qnil
;
1723 XSYMBOL (Qt
)->value
= Qt
;
1725 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1728 Qvariable_documentation
= intern ("variable-documentation");
1730 read_buffer_size
= 100;
1731 read_buffer
= (char *) malloc (read_buffer_size
);
1736 struct Lisp_Subr
*sname
;
1739 sym
= intern (sname
->symbol_name
);
1740 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1743 #ifdef NOTDEF /* use fset in subr.el now */
1745 defalias (sname
, string
)
1746 struct Lisp_Subr
*sname
;
1750 sym
= intern (string
);
1751 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1755 /* New replacement for DefIntVar; it ignores the doc string argument
1756 on the assumption that make-docfile will handle that. */
1757 /* Define an "integer variable"; a symbol whose value is forwarded
1758 to a C variable of type int. Sample call: */
1759 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1762 defvar_int (namestring
, address
, doc
)
1768 sym
= intern (namestring
);
1769 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1772 /* Similar but define a variable whose value is T if address contains 1,
1773 NIL if address contains 0 */
1776 defvar_bool (namestring
, address
, doc
)
1782 sym
= intern (namestring
);
1783 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1786 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1789 defvar_lisp (namestring
, address
, doc
)
1791 Lisp_Object
*address
;
1795 sym
= intern (namestring
);
1796 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1797 staticpro (address
);
1800 /* Similar but don't request gc-marking of the C variable.
1801 Used when that variable will be gc-marked for some other reason,
1802 since marking the same slot twice can cause trouble with strings. */
1805 defvar_lisp_nopro (namestring
, address
, doc
)
1807 Lisp_Object
*address
;
1811 sym
= intern (namestring
);
1812 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1817 /* Similar but define a variable whose value is the Lisp Object stored in
1818 the current buffer. address is the address of the slot in the buffer that is current now. */
1821 defvar_per_buffer (namestring
, address
, type
, doc
)
1823 Lisp_Object
*address
;
1829 extern struct buffer buffer_local_symbols
;
1831 sym
= intern (namestring
);
1832 offset
= (char *)address
- (char *)current_buffer
;
1834 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1835 (Lisp_Object
*) offset
);
1836 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1837 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1838 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1839 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1840 slot of buffer_local_flags */
1844 #endif /* standalone */
1850 /* Compute the default load-path. */
1852 normal
= PATH_LOADSEARCH
;
1853 Vload_path
= decode_env_path (0, normal
);
1855 if (NILP (Vpurify_flag
))
1856 normal
= PATH_LOADSEARCH
;
1858 normal
= PATH_DUMPLOADSEARCH
;
1860 /* In a dumped Emacs, we normally have to reset the value of
1861 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1862 uses ../lisp, instead of the path of the installed elisp
1863 libraries. However, if it appears that Vload_path was changed
1864 from the default before dumping, don't override that value. */
1867 Lisp_Object dump_path
;
1869 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1870 if (! NILP (Fequal (dump_path
, Vload_path
)))
1872 Vload_path
= decode_env_path (0, normal
);
1873 if (!NILP (Vinstallation_directory
))
1875 /* Add to the path the lisp subdir of the
1876 installation dir, if it exists. */
1877 Lisp_Object tem
, tem1
;
1878 tem
= Fexpand_file_name (build_string ("lisp"),
1879 Vinstallation_directory
);
1880 tem1
= Ffile_exists_p (tem
);
1883 if (NILP (Fmember (tem
, Vload_path
)))
1884 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1887 /* That dir doesn't exist, so add the build-time
1888 Lisp dirs instead. */
1889 Vload_path
= nconc2 (Vload_path
, dump_path
);
1894 Vload_path
= decode_env_path (0, normal
);
1897 /* Warn if dirs in the *standard* path don't exist. */
1899 Lisp_Object path_tail
;
1901 for (path_tail
= Vload_path
;
1903 path_tail
= XCONS (path_tail
)->cdr
)
1905 Lisp_Object dirfile
;
1906 dirfile
= Fcar (path_tail
);
1907 if (XTYPE (dirfile
) == Lisp_String
)
1909 dirfile
= Fdirectory_file_name (dirfile
);
1910 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1912 "Warning: Lisp directory `%s' does not exist.\n",
1913 XSTRING (Fcar (path_tail
))->data
);
1918 /* If the EMACSLOADPATH environment variable is set, use its value.
1919 This doesn't apply if we're dumping. */
1920 if (NILP (Vpurify_flag
)
1921 && egetenv ("EMACSLOADPATH"))
1922 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1926 load_in_progress
= 0;
1928 load_descriptor_list
= Qnil
;
1935 defsubr (&Sread_from_string
);
1937 defsubr (&Sintern_soft
);
1939 defsubr (&Seval_buffer
);
1940 defsubr (&Seval_region
);
1941 defsubr (&Sread_char
);
1942 defsubr (&Sread_char_exclusive
);
1943 defsubr (&Sread_event
);
1944 defsubr (&Sget_file_char
);
1945 defsubr (&Smapatoms
);
1947 DEFVAR_LISP ("obarray", &Vobarray
,
1948 "Symbol table for use by `intern' and `read'.\n\
1949 It is a vector whose length ought to be prime for best results.\n\
1950 The vector's contents don't make sense if examined from Lisp programs;\n\
1951 to find all the symbols in an obarray, use `mapatoms'.");
1953 DEFVAR_LISP ("values", &Vvalues
,
1954 "List of values of all expressions which were read, evaluated and printed.\n\
1955 Order is reverse chronological.");
1957 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1958 "Stream for read to get input from.\n\
1959 See documentation of `read' for possible values.");
1960 Vstandard_input
= Qt
;
1962 DEFVAR_LISP ("load-path", &Vload_path
,
1963 "*List of directories to search for files to load.\n\
1964 Each element is a string (directory name) or nil (try default directory).\n\
1965 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1966 otherwise to default specified by file `paths.h' when Emacs was built.");
1968 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1969 "Non-nil iff inside of `load'.");
1971 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1972 "An alist of expressions to be evalled when particular files are loaded.\n\
1973 Each element looks like (FILENAME FORMS...).\n\
1974 When `load' is run and the file-name argument is FILENAME,\n\
1975 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1976 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1977 with no directory specified, since that is how `load' is normally called.\n\
1978 An error in FORMS does not undo the load,\n\
1979 but does prevent execution of the rest of the FORMS.");
1980 Vafter_load_alist
= Qnil
;
1982 DEFVAR_LISP ("load-history", &Vload_history
,
1983 "Alist mapping source file names to symbols and features.\n\
1984 Each alist element is a list that starts with a file name,\n\
1985 except for one element (optional) that starts with nil and describes\n\
1986 definitions evaluated from buffers not visiting files.\n\
1987 The remaining elements of each list are symbols defined as functions\n\
1988 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1989 Vload_history
= Qnil
;
1991 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1992 "Used for internal purposes by `load'.");
1993 Vcurrent_load_list
= Qnil
;
1995 load_descriptor_list
= Qnil
;
1996 staticpro (&load_descriptor_list
);
1998 Qcurrent_load_list
= intern ("current-load-list");
1999 staticpro (&Qcurrent_load_list
);
2001 Qstandard_input
= intern ("standard-input");
2002 staticpro (&Qstandard_input
);
2004 Qread_char
= intern ("read-char");
2005 staticpro (&Qread_char
);
2007 Qget_file_char
= intern ("get-file-char");
2008 staticpro (&Qget_file_char
);
2010 Qascii_character
= intern ("ascii-character");
2011 staticpro (&Qascii_character
);
2013 Qload
= intern ("load");