1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989,
3 1993, 1994 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include <sys/types.h>
36 #include "termhooks.h"
40 #include <sys/inode.h>
47 #ifdef LISP_FLOAT_TYPE
54 /* These are redefined (correctly, but differently) in values.h. */
61 #endif /* LISP_FLOAT_TYPE */
65 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
66 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
67 Lisp_Object Qascii_character
, Qload
;
69 extern Lisp_Object Qevent_symbol_element_mask
;
71 /* non-zero if inside `load' */
74 /* Search path for files to be loaded. */
75 Lisp_Object Vload_path
;
77 /* This is the user-visible association list that maps features to
78 lists of defs in their load files. */
79 Lisp_Object Vload_history
;
81 /* This is useud to build the load history. */
82 Lisp_Object Vcurrent_load_list
;
84 /* List of descriptors now open for Fload. */
85 static Lisp_Object load_descriptor_list
;
87 /* File for get_file_char to read from. Use by load */
88 static FILE *instream
;
90 /* When nonzero, read conses in pure space */
93 /* For use within read-from-string (this reader is non-reentrant!!) */
94 static int read_from_string_index
;
95 static int read_from_string_limit
;
97 /* Handle unreading and rereading of characters.
98 Write READCHAR to read a character,
99 UNREAD(c) to unread c to be read again. */
101 #define READCHAR readchar (readcharfun)
102 #define UNREAD(c) unreadchar (readcharfun, c)
105 readchar (readcharfun
)
106 Lisp_Object readcharfun
;
109 register struct buffer
*inbuffer
;
110 register int c
, mpos
;
112 if (XTYPE (readcharfun
) == Lisp_Buffer
)
114 inbuffer
= XBUFFER (readcharfun
);
116 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
118 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
119 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
123 if (XTYPE (readcharfun
) == Lisp_Marker
)
125 inbuffer
= XMARKER (readcharfun
)->buffer
;
127 mpos
= marker_position (readcharfun
);
129 if (mpos
> BUF_ZV (inbuffer
) - 1)
131 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
132 if (mpos
!= BUF_GPT (inbuffer
))
133 XMARKER (readcharfun
)->bufpos
++;
135 Fset_marker (readcharfun
, make_number (mpos
+ 1),
136 Fmarker_buffer (readcharfun
));
139 if (EQ (readcharfun
, Qget_file_char
))
143 /* Interrupted reads have been observed while reading over the network */
144 while (c
== EOF
&& ferror (instream
) && errno
== EINTR
)
153 if (XTYPE (readcharfun
) == Lisp_String
)
156 /* This used to be return of a conditional expression,
157 but that truncated -1 to a char on VMS. */
158 if (read_from_string_index
< read_from_string_limit
)
159 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
165 tem
= call0 (readcharfun
);
172 /* Unread the character C in the way appropriate for the stream READCHARFUN.
173 If the stream is a user function, call it with the char as argument. */
176 unreadchar (readcharfun
, c
)
177 Lisp_Object readcharfun
;
181 /* Don't back up the pointer if we're unreading the end-of-input mark,
182 since readchar didn't advance it when we read it. */
184 else if (XTYPE (readcharfun
) == Lisp_Buffer
)
186 if (XBUFFER (readcharfun
) == current_buffer
)
189 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
191 else if (XTYPE (readcharfun
) == Lisp_Marker
)
192 XMARKER (readcharfun
)->bufpos
--;
193 else if (XTYPE (readcharfun
) == Lisp_String
)
194 read_from_string_index
--;
195 else if (EQ (readcharfun
, Qget_file_char
))
196 ungetc (c
, instream
);
198 call1 (readcharfun
, make_number (c
));
201 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
203 /* get a character from the tty */
205 extern Lisp_Object
read_char ();
207 /* Read input events until we get one that's acceptable for our purposes.
209 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
210 until we get a character we like, and then stuffed into
213 If ASCII_REQUIRED is non-zero, we check function key events to see
214 if the unmodified version of the symbol has a Qascii_character
215 property, and use that character, if present.
217 If ERROR_NONASCII is non-zero, we signal an error if the input we
218 get isn't an ASCII character with modifiers. If it's zero but
219 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
222 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
223 int no_switch_frame
, ascii_required
, error_nonascii
;
226 return make_number (getchar ());
228 register Lisp_Object val
, delayed_switch_frame
;
230 delayed_switch_frame
= Qnil
;
232 /* Read until we get an acceptable event. */
234 val
= read_char (0, 0, 0, Qnil
, 0);
236 if (XTYPE (val
) == Lisp_Buffer
)
239 /* switch-frame events are put off until after the next ASCII
240 character. This is better than signalling an error just because
241 the last characters were typed to a separate minibuffer frame,
242 for example. Eventually, some code which can deal with
243 switch-frame events will read it and process it. */
245 && EVENT_HAS_PARAMETERS (val
)
246 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
248 delayed_switch_frame
= val
;
254 /* Convert certain symbols to their ASCII equivalents. */
255 if (XTYPE (val
) == Lisp_Symbol
)
257 Lisp_Object tem
, tem1
, tem2
;
258 tem
= Fget (val
, Qevent_symbol_element_mask
);
261 tem1
= Fget (Fcar (tem
), Qascii_character
);
262 /* Merge this symbol's modifier bits
263 with the ASCII equivalent of its basic code. */
265 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
269 /* If we don't have a character now, deal with it appropriately. */
270 if (XTYPE (val
) != Lisp_Int
)
274 Vunread_command_events
= Fcons (val
, Qnil
);
275 error ("Non-character input-event");
282 if (! NILP (delayed_switch_frame
))
283 unread_switch_frame
= delayed_switch_frame
;
289 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
290 "Read a character from the command input (keyboard or macro).\n\
291 It is returned as a number.\n\
292 If the user generates an event which is not a character (i.e. a mouse\n\
293 click or function key event), `read-char' signals an error. As an\n\
294 exception, switch-frame events are put off until non-ASCII events can\n\
296 If you want to read non-character events, or ignore them, call\n\
297 `read-event' or `read-char-exclusive' instead.")
300 return read_filtered_event (1, 1, 1);
303 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
304 "Read an event object from the input stream.")
307 return read_filtered_event (0, 0, 0);
310 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
311 "Read a character from the command input (keyboard or macro).\n\
312 It is returned as a number. Non character events are ignored.")
315 return read_filtered_event (1, 1, 0);
318 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
319 "Don't use this yourself.")
322 register Lisp_Object val
;
323 XSET (val
, Lisp_Int
, getc (instream
));
327 static void readevalloop ();
328 static Lisp_Object
load_unwind ();
329 static Lisp_Object
load_descriptor_unwind ();
331 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
332 "Execute a file of Lisp code named FILE.\n\
333 First try FILE with `.elc' appended, then try with `.el',\n\
334 then try FILE unmodified.\n\
335 This function searches the directories in `load-path'.\n\
336 If optional second arg NOERROR is non-nil,\n\
337 report no error if FILE doesn't exist.\n\
338 Print messages at start and end of loading unless\n\
339 optional third arg NOMESSAGE is non-nil.\n\
340 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
341 suffixes `.elc' or `.el' to the specified name FILE.\n\
342 Return t if file exists.")
343 (str
, noerror
, nomessage
, nosuffix
)
344 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
346 register FILE *stream
;
347 register int fd
= -1;
348 register Lisp_Object lispstream
;
350 int count
= specpdl_ptr
- specpdl
;
354 /* 1 means inhibit the message at the beginning. */
358 char *dosmode
= "rt";
361 CHECK_STRING (str
, 0);
362 str
= Fsubstitute_in_file_name (str
);
364 /* If file name is magic, call the handler. */
365 handler
= Ffind_file_name_handler (str
, Qload
);
367 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
369 /* Avoid weird lossage with null string as arg,
370 since it would try to load a directory as a Lisp file */
371 if (XSTRING (str
)->size
> 0)
374 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
383 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
389 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
398 stat ((char *)XSTRING (found
)->data
, &s1
);
399 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
400 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
401 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
403 message ("Source file `%s' newer than byte-compiled file",
404 XSTRING (found
)->data
);
405 /* Don't immediately overwrite this message. */
409 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
414 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
416 stream
= fdopen (fd
, "r");
421 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
424 if (NILP (nomessage
) && !nomessage1
)
425 message ("Loading %s...", XSTRING (str
)->data
);
428 /* We may not be able to store STREAM itself as a Lisp_Object pointer
429 since that is guaranteed to work only for data that has been malloc'd.
430 So malloc a full-size pointer, and record the address of that pointer. */
431 ptr
= (FILE **) xmalloc (sizeof (FILE *));
433 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
434 record_unwind_protect (load_unwind
, lispstream
);
435 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
437 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
439 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
440 unbind_to (count
, Qnil
);
442 /* Run any load-hooks for this file. */
443 temp
= Fassoc (str
, Vafter_load_alist
);
445 Fprogn (Fcdr (temp
));
448 if (!noninteractive
&& NILP (nomessage
))
449 message ("Loading %s...done", XSTRING (str
)->data
);
454 load_unwind (stream
) /* used as unwind-protect function in load */
457 fclose (*(FILE **) XSTRING (stream
));
458 xfree (XPNTR (stream
));
459 if (--load_in_progress
< 0) load_in_progress
= 0;
464 load_descriptor_unwind (oldlist
)
467 load_descriptor_list
= oldlist
;
470 /* Close all descriptors in use for Floads.
471 This is used when starting a subprocess. */
477 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
478 close (XFASTINT (XCONS (tail
)->car
));
482 complete_filename_p (pathname
)
483 Lisp_Object pathname
;
485 register unsigned char *s
= XSTRING (pathname
)->data
;
493 #ifdef MSDOS /* MW, May 1993 */
494 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
499 /* Search for a file whose name is STR, looking in directories
500 in the Lisp list PATH, and trying suffixes from SUFFIX.
501 SUFFIX is a string containing possible suffixes separated by colons.
502 On success, returns a file descriptor. On failure, returns -1.
504 EXEC_ONLY nonzero means don't open the files,
505 just look for one that is executable. In this case,
506 returns 1 on success.
508 If STOREPTR is nonzero, it points to a slot where the name of
509 the file actually found should be stored as a Lisp string.
510 Nil is stored there on failure. */
513 openp (path
, str
, suffix
, storeptr
, exec_only
)
514 Lisp_Object path
, str
;
516 Lisp_Object
*storeptr
;
522 register char *fn
= buf
;
525 register Lisp_Object filename
;
533 if (complete_filename_p (str
))
536 for (; !NILP (path
); path
= Fcdr (path
))
540 filename
= Fexpand_file_name (str
, Fcar (path
));
541 if (!complete_filename_p (filename
))
542 /* If there are non-absolute elts in PATH (eg ".") */
543 /* Of course, this could conceivably lose if luser sets
544 default-directory to be something non-absolute... */
546 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
547 if (!complete_filename_p (filename
))
548 /* Give up on this path element! */
552 /* Calculate maximum size of any filename made from
553 this path element/specified file name and any possible suffix. */
554 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
555 if (fn_size
< want_size
)
556 fn
= (char *) alloca (fn_size
= 100 + want_size
);
560 /* Loop over suffixes. */
563 char *esuffix
= (char *) index (nsuffix
, ':');
564 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
566 /* Concatenate path element/specified name with the suffix. */
567 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
568 fn
[XSTRING (filename
)->size
] = 0;
569 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
570 strncat (fn
, nsuffix
, lsuffix
);
572 /* Ignore file if it's a directory. */
573 if (stat (fn
, &st
) >= 0
574 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
576 /* Check that we can access or open it. */
578 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
580 fd
= open (fn
, 0, 0);
584 /* We succeeded; return this descriptor and filename. */
586 *storeptr
= build_string (fn
);
591 /* Advance to next suffix. */
594 nsuffix
+= lsuffix
+ 1;
604 /* Merge the list we've accumulated of globals from the current input source
605 into the load_history variable. The details depend on whether
606 the source has an associated file name or not. */
609 build_load_history (stream
, source
)
613 register Lisp_Object tail
, prev
, newelt
;
614 register Lisp_Object tem
, tem2
;
615 register int foundit
, loading
;
617 /* Don't bother recording anything for preloaded files. */
618 if (!NILP (Vpurify_flag
))
621 loading
= stream
|| !NARROWED
;
623 tail
= Vload_history
;
630 /* Find the feature's previous assoc list... */
631 if (!NILP (Fequal (source
, Fcar (tem
))))
635 /* If we're loading, remove it. */
639 Vload_history
= Fcdr (tail
);
641 Fsetcdr (prev
, Fcdr (tail
));
644 /* Otherwise, cons on new symbols that are not already members. */
647 tem2
= Vcurrent_load_list
;
651 newelt
= Fcar (tem2
);
653 if (NILP (Fmemq (newelt
, tem
)))
654 Fsetcar (tail
, Fcons (Fcar (tem
),
655 Fcons (newelt
, Fcdr (tem
))));
668 /* If we're loading, cons the new assoc onto the front of load-history,
669 the most-recently-loaded position. Also do this if we didn't find
670 an existing member for the current source. */
671 if (loading
|| !foundit
)
672 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
677 unreadpure () /* Used as unwind-protect function in readevalloop */
684 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
685 Lisp_Object readcharfun
;
687 Lisp_Object sourcename
;
688 Lisp_Object (*evalfun
) ();
692 register Lisp_Object val
;
693 int count
= specpdl_ptr
- specpdl
;
695 struct buffer
*b
= 0;
697 if (BUFFERP (readcharfun
))
698 b
= XBUFFER (readcharfun
);
699 else if (MARKERP (readcharfun
))
700 b
= XMARKER (readcharfun
)->buffer
;
702 specbind (Qstandard_input
, readcharfun
);
703 specbind (Qcurrent_load_list
, Qnil
);
707 LOADHIST_ATTACH (sourcename
);
711 if (b
!= 0 && NILP (b
->name
))
712 error ("Reading from killed buffer");
718 while ((c
= READCHAR
) != '\n' && c
!= -1);
722 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
724 if (!NILP (Vpurify_flag
) && c
== '(')
726 int count1
= specpdl_ptr
- specpdl
;
727 record_unwind_protect (unreadpure
, Qnil
);
728 val
= read_list (-1, readcharfun
);
729 unbind_to (count1
, Qnil
);
734 val
= read0 (readcharfun
);
737 val
= (*evalfun
) (val
);
740 Vvalues
= Fcons (val
, Vvalues
);
741 if (EQ (Vstandard_output
, Qt
))
748 build_load_history (stream
, sourcename
);
751 unbind_to (count
, Qnil
);
756 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
757 "Execute the current buffer as Lisp code.\n\
758 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
759 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
760 PRINTFLAG controls printing of output:\n\
761 nil means discard it; anything else is stream for print.\n\
763 If there is no error, point does not move. If there is an error,\n\
764 point remains at the end of the last character read from the buffer.")
766 Lisp_Object bufname
, printflag
;
768 int count
= specpdl_ptr
- specpdl
;
769 Lisp_Object tem
, buf
;
772 buf
= Fcurrent_buffer ();
774 buf
= Fget_buffer (bufname
);
776 error ("No such buffer.");
778 if (NILP (printflag
))
782 specbind (Qstandard_output
, tem
);
783 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
784 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
785 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
786 unbind_to (count
, Qnil
);
792 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
793 "Execute the current buffer as Lisp code.\n\
794 Programs can pass argument PRINTFLAG which controls printing of output:\n\
795 nil means discard it; anything else is stream for print.\n\
797 If there is no error, point does not move. If there is an error,\n\
798 point remains at the end of the last character read from the buffer.")
800 Lisp_Object printflag
;
802 int count
= specpdl_ptr
- specpdl
;
803 Lisp_Object tem
, cbuf
;
805 cbuf
= Fcurrent_buffer ()
807 if (NILP (printflag
))
811 specbind (Qstandard_output
, tem
);
812 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
814 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
815 return unbind_to (count
, Qnil
);
819 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
820 "Execute the region as Lisp code.\n\
821 When called from programs, expects two arguments,\n\
822 giving starting and ending indices in the current buffer\n\
823 of the text to be executed.\n\
824 Programs can pass third argument PRINTFLAG which controls output:\n\
825 nil means discard it; anything else is stream for printing it.\n\
827 If there is no error, point does not move. If there is an error,\n\
828 point remains at the end of the last character read from the buffer.")
830 Lisp_Object b
, e
, printflag
;
832 int count
= specpdl_ptr
- specpdl
;
833 Lisp_Object tem
, cbuf
;
835 cbuf
= Fcurrent_buffer ();
837 if (NILP (printflag
))
841 specbind (Qstandard_output
, tem
);
843 if (NILP (printflag
))
844 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
845 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
847 /* This both uses b and checks its type. */
849 Fnarrow_to_region (make_number (BEGV
), e
);
850 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
852 return unbind_to (count
, Qnil
);
855 #endif /* standalone */
857 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
858 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
859 If STREAM is nil, use the value of `standard-input' (which see).\n\
860 STREAM or the value of `standard-input' may be:\n\
861 a buffer (read from point and advance it)\n\
862 a marker (read from where it points and advance it)\n\
863 a function (call it with no arguments for each character,\n\
864 call it with a char as argument to push a char back)\n\
865 a string (takes text from string, starting at the beginning)\n\
866 t (read text line using minibuffer and use it).")
868 Lisp_Object readcharfun
;
870 extern Lisp_Object
Fread_minibuffer ();
872 if (NILP (readcharfun
))
873 readcharfun
= Vstandard_input
;
874 if (EQ (readcharfun
, Qt
))
875 readcharfun
= Qread_char
;
878 if (EQ (readcharfun
, Qread_char
))
879 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
882 if (XTYPE (readcharfun
) == Lisp_String
)
883 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
885 return read0 (readcharfun
);
888 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
889 "Read one Lisp expression which is represented as text by STRING.\n\
890 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
891 START and END optionally delimit a substring of STRING from which to read;\n\
892 they default to 0 and (length STRING) respectively.")
894 Lisp_Object string
, start
, end
;
896 int startval
, endval
;
899 CHECK_STRING (string
,0);
902 endval
= XSTRING (string
)->size
;
904 { CHECK_NUMBER (end
,2);
906 if (endval
< 0 || endval
> XSTRING (string
)->size
)
907 args_out_of_range (string
, end
);
913 { CHECK_NUMBER (start
,1);
914 startval
= XINT (start
);
915 if (startval
< 0 || startval
> endval
)
916 args_out_of_range (string
, start
);
919 read_from_string_index
= startval
;
920 read_from_string_limit
= endval
;
922 tem
= read0 (string
);
923 return Fcons (tem
, make_number (read_from_string_index
));
926 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
930 Lisp_Object readcharfun
;
932 register Lisp_Object val
;
935 val
= read1 (readcharfun
);
936 if (XTYPE (val
) == Lisp_Internal
)
939 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
945 static int read_buffer_size
;
946 static char *read_buffer
;
949 read_escape (readcharfun
)
950 Lisp_Object readcharfun
;
952 register int c
= READCHAR
;
979 error ("Invalid escape character syntax");
982 c
= read_escape (readcharfun
);
983 return c
| meta_modifier
;
988 error ("Invalid escape character syntax");
991 c
= read_escape (readcharfun
);
992 return c
| shift_modifier
;
997 error ("Invalid escape character syntax");
1000 c
= read_escape (readcharfun
);
1001 return c
| hyper_modifier
;
1006 error ("Invalid escape character syntax");
1009 c
= read_escape (readcharfun
);
1010 return c
| alt_modifier
;
1015 error ("Invalid escape character syntax");
1018 c
= read_escape (readcharfun
);
1019 return c
| super_modifier
;
1024 error ("Invalid escape character syntax");
1028 c
= read_escape (readcharfun
);
1029 if ((c
& 0177) == '?')
1031 /* ASCII control chars are made from letters (both cases),
1032 as well as the non-letters within 0100...0137. */
1033 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1034 return (c
& (037 | ~0177));
1035 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1036 return (c
& (037 | ~0177));
1038 return c
| ctrl_modifier
;
1048 /* An octal escape, as in ANSI C. */
1050 register int i
= c
- '0';
1051 register int count
= 0;
1054 if ((c
= READCHAR
) >= '0' && c
<= '7')
1069 /* A hex escape, as in ANSI C. */
1075 if (c
>= '0' && c
<= '9')
1080 else if ((c
>= 'a' && c
<= 'f')
1081 || (c
>= 'A' && c
<= 'F'))
1084 if (c
>= 'a' && c
<= 'f')
1105 register Lisp_Object readcharfun
;
1112 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1117 return read_list (0, readcharfun
);
1120 return read_vector (readcharfun
);
1125 register Lisp_Object val
;
1126 XSET (val
, Lisp_Internal
, c
);
1134 /* Accept compiled functions at read-time so that we don't have to
1135 build them using function calls. */
1137 tmp
= read_vector (readcharfun
);
1138 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1139 XVECTOR (tmp
)->contents
);
1141 #ifdef USE_TEXT_PROPERTIES
1145 struct gcpro gcpro1
;
1147 /* Read the string itself. */
1148 tmp
= read1 (readcharfun
);
1149 if (XTYPE (tmp
) != Lisp_String
)
1150 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1152 /* Read the intervals and their properties. */
1155 Lisp_Object beg
, end
, plist
;
1157 beg
= read1 (readcharfun
);
1158 if (XTYPE (beg
) == Lisp_Internal
)
1160 if (XINT (beg
) == ')')
1162 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1164 end
= read1 (readcharfun
);
1165 if (XTYPE (end
) == Lisp_Internal
)
1166 Fsignal (Qinvalid_read_syntax
,
1167 Fcons (make_string ("invalid string property list", 28), Qnil
));
1169 plist
= read1 (readcharfun
);
1170 if (XTYPE (plist
) == Lisp_Internal
)
1171 Fsignal (Qinvalid_read_syntax
,
1172 Fcons (make_string ("invalid string property list", 28), Qnil
));
1173 Fset_text_properties (beg
, end
, plist
, tmp
);
1180 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1183 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1188 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1193 register Lisp_Object val
;
1196 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1199 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1201 XSET (val
, Lisp_Int
, c
);
1208 register char *p
= read_buffer
;
1209 register char *end
= read_buffer
+ read_buffer_size
;
1213 while ((c
= READCHAR
) >= 0
1218 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1219 p
+= new - read_buffer
;
1220 read_buffer
+= new - read_buffer
;
1221 end
= read_buffer
+ read_buffer_size
;
1224 c
= read_escape (readcharfun
);
1225 /* c is -1 if \ newline has just been seen */
1228 if (p
== read_buffer
)
1233 /* Allow `\C- ' and `\C-?'. */
1234 if (c
== (CHAR_CTL
| ' '))
1236 else if (c
== (CHAR_CTL
| '?'))
1240 /* Move the meta bit to the right place for a string. */
1241 c
= (c
& ~CHAR_META
) | 0x80;
1243 error ("Invalid modifier in string");
1247 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1249 /* If purifying, and string starts with \ newline,
1250 return zero instead. This is for doc strings
1251 that we are really going to find in etc/DOC.nn.nn */
1252 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1253 return make_number (0);
1256 return make_pure_string (read_buffer
, p
- read_buffer
);
1258 return make_string (read_buffer
, p
- read_buffer
);
1263 #ifdef LISP_FLOAT_TYPE
1264 /* If a period is followed by a number, then we should read it
1265 as a floating point number. Otherwise, it denotes a dotted
1267 int next_char
= READCHAR
;
1270 if (! isdigit (next_char
))
1273 register Lisp_Object val
;
1274 XSET (val
, Lisp_Internal
, c
);
1278 /* Otherwise, we fall through! Note that the atom-reading loop
1279 below will now loop at least once, assuring that we will not
1280 try to UNREAD two characters in a row. */
1283 if (c
<= 040) goto retry
;
1285 register char *p
= read_buffer
;
1289 register char *end
= read_buffer
+ read_buffer_size
;
1292 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1293 || c
== '(' || c
== ')'
1294 #ifndef LISP_FLOAT_TYPE
1295 /* If we have floating-point support, then we need
1296 to allow <digits><dot><digits>. */
1298 #endif /* not LISP_FLOAT_TYPE */
1299 || c
== '[' || c
== ']' || c
== '#'
1304 register 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
;
1320 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1321 p
+= new - read_buffer
;
1322 read_buffer
+= new - read_buffer
;
1323 /* end = read_buffer + read_buffer_size; */
1333 register Lisp_Object val
;
1335 if (*p1
== '+' || *p1
== '-') p1
++;
1336 /* Is it an integer? */
1339 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1340 #ifdef LISP_FLOAT_TYPE
1341 /* Integers can have trailing decimal points. */
1342 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1345 /* It is an integer. */
1347 #ifdef LISP_FLOAT_TYPE
1351 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1355 #ifdef LISP_FLOAT_TYPE
1356 if (isfloat_string (read_buffer
))
1357 return make_float (atof (read_buffer
));
1361 return intern (read_buffer
);
1366 #ifdef LISP_FLOAT_TYPE
1381 if (*cp
== '+' || *cp
== '-')
1387 while (isdigit (*cp
))
1398 while (isdigit (*cp
))
1406 if ((*cp
== '+') || (*cp
== '-'))
1412 while (isdigit (*cp
))
1416 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1417 || state
== (DOT_CHAR
|TRAIL_INT
)
1418 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1419 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1420 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1422 #endif /* LISP_FLOAT_TYPE */
1425 read_vector (readcharfun
)
1426 Lisp_Object readcharfun
;
1430 register Lisp_Object
*ptr
;
1431 register Lisp_Object tem
, vector
;
1432 register struct Lisp_Cons
*otem
;
1435 tem
= read_list (1, readcharfun
);
1436 len
= Flength (tem
);
1437 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1440 size
= XVECTOR (vector
)->size
;
1441 ptr
= XVECTOR (vector
)->contents
;
1442 for (i
= 0; i
< size
; i
++)
1444 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1452 /* flag = 1 means check for ] to terminate rather than ) and .
1453 flag = -1 means check for starting with defun
1454 and make structure pure. */
1457 read_list (flag
, readcharfun
)
1459 register Lisp_Object readcharfun
;
1461 /* -1 means check next element for defun,
1462 0 means don't check,
1463 1 means already checked and found defun. */
1464 int defunflag
= flag
< 0 ? -1 : 0;
1465 Lisp_Object val
, tail
;
1466 register Lisp_Object elt
, tem
;
1467 struct gcpro gcpro1
, gcpro2
;
1475 elt
= read1 (readcharfun
);
1477 if (XTYPE (elt
) == Lisp_Internal
)
1481 if (XINT (elt
) == ']')
1483 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1485 if (XINT (elt
) == ')')
1487 if (XINT (elt
) == '.')
1491 XCONS (tail
)->cdr
= read0 (readcharfun
);
1493 val
= read0 (readcharfun
);
1494 elt
= read1 (readcharfun
);
1496 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1498 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1500 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1502 tem
= (read_pure
&& flag
<= 0
1503 ? pure_cons (elt
, Qnil
)
1504 : Fcons (elt
, Qnil
));
1506 XCONS (tail
)->cdr
= tem
;
1511 defunflag
= EQ (elt
, Qdefun
);
1512 else if (defunflag
> 0)
1517 Lisp_Object Vobarray
;
1518 Lisp_Object initial_obarray
;
1521 check_obarray (obarray
)
1522 Lisp_Object obarray
;
1524 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1526 /* If Vobarray is now invalid, force it to be valid. */
1527 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1529 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1534 static int hash_string ();
1535 Lisp_Object
oblookup ();
1542 int len
= strlen (str
);
1543 Lisp_Object obarray
;
1546 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1547 obarray
= check_obarray (obarray
);
1548 tem
= oblookup (obarray
, str
, len
);
1549 if (XTYPE (tem
) == Lisp_Symbol
)
1551 return Fintern ((!NILP (Vpurify_flag
)
1552 ? make_pure_string (str
, len
)
1553 : make_string (str
, len
)),
1557 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1558 "Return the canonical symbol whose name is STRING.\n\
1559 If there is none, one is created by this function and returned.\n\
1560 A second optional argument specifies the obarray to use;\n\
1561 it defaults to the value of `obarray'.")
1563 Lisp_Object str
, obarray
;
1565 register Lisp_Object tem
, sym
, *ptr
;
1567 if (NILP (obarray
)) obarray
= Vobarray
;
1568 obarray
= check_obarray (obarray
);
1570 CHECK_STRING (str
, 0);
1572 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1573 if (XTYPE (tem
) != Lisp_Int
)
1576 if (!NILP (Vpurify_flag
))
1577 str
= Fpurecopy (str
);
1578 sym
= Fmake_symbol (str
);
1580 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1581 if (XTYPE (*ptr
) == Lisp_Symbol
)
1582 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1584 XSYMBOL (sym
)->next
= 0;
1589 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1590 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1591 A second optional argument specifies the obarray to use;\n\
1592 it defaults to the value of `obarray'.")
1594 Lisp_Object str
, obarray
;
1596 register Lisp_Object tem
;
1598 if (NILP (obarray
)) obarray
= Vobarray
;
1599 obarray
= check_obarray (obarray
);
1601 CHECK_STRING (str
, 0);
1603 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1604 if (XTYPE (tem
) != Lisp_Int
)
1610 oblookup (obarray
, ptr
, size
)
1611 Lisp_Object obarray
;
1616 register Lisp_Object tail
;
1617 Lisp_Object bucket
, tem
;
1619 if (XTYPE (obarray
) != Lisp_Vector
1620 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1622 obarray
= check_obarray (obarray
);
1623 obsize
= XVECTOR (obarray
)->size
;
1625 /* Combining next two lines breaks VMS C 2.3. */
1626 hash
= hash_string (ptr
, size
);
1628 bucket
= XVECTOR (obarray
)->contents
[hash
];
1629 if (XFASTINT (bucket
) == 0)
1631 else if (XTYPE (bucket
) != Lisp_Symbol
)
1632 error ("Bad data in guts of obarray"); /* Like CADR error message */
1633 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1635 if (XSYMBOL (tail
)->name
->size
== size
&&
1636 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1638 else if (XSYMBOL (tail
)->next
== 0)
1641 XSET (tem
, Lisp_Int
, hash
);
1646 hash_string (ptr
, len
)
1650 register unsigned char *p
= ptr
;
1651 register unsigned char *end
= p
+ len
;
1652 register unsigned char c
;
1653 register int hash
= 0;
1658 if (c
>= 0140) c
-= 40;
1659 hash
= ((hash
<<3) + (hash
>>28) + c
);
1661 return hash
& 07777777777;
1665 map_obarray (obarray
, fn
, arg
)
1666 Lisp_Object obarray
;
1671 register Lisp_Object tail
;
1672 CHECK_VECTOR (obarray
, 1);
1673 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1675 tail
= XVECTOR (obarray
)->contents
[i
];
1676 if (XFASTINT (tail
) != 0)
1680 if (XSYMBOL (tail
)->next
== 0)
1682 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1687 mapatoms_1 (sym
, function
)
1688 Lisp_Object sym
, function
;
1690 call1 (function
, sym
);
1693 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1694 "Call FUNCTION on every symbol in OBARRAY.\n\
1695 OBARRAY defaults to the value of `obarray'.")
1697 Lisp_Object function
, obarray
;
1701 if (NILP (obarray
)) obarray
= Vobarray
;
1702 obarray
= check_obarray (obarray
);
1704 map_obarray (obarray
, mapatoms_1
, function
);
1708 #define OBARRAY_SIZE 1511
1713 Lisp_Object oblength
;
1717 XFASTINT (oblength
) = OBARRAY_SIZE
;
1719 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1720 Vobarray
= Fmake_vector (oblength
, make_number (0));
1721 initial_obarray
= Vobarray
;
1722 staticpro (&initial_obarray
);
1723 /* Intern nil in the obarray */
1724 /* These locals are to kludge around a pyramid compiler bug. */
1725 hash
= hash_string ("nil", 3);
1726 /* Separate statement here to avoid VAXC bug. */
1727 hash
%= OBARRAY_SIZE
;
1728 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1731 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1732 XSYMBOL (Qnil
)->function
= Qunbound
;
1733 XSYMBOL (Qunbound
)->value
= Qunbound
;
1734 XSYMBOL (Qunbound
)->function
= Qunbound
;
1737 XSYMBOL (Qnil
)->value
= Qnil
;
1738 XSYMBOL (Qnil
)->plist
= Qnil
;
1739 XSYMBOL (Qt
)->value
= Qt
;
1741 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1744 Qvariable_documentation
= intern ("variable-documentation");
1746 read_buffer_size
= 100;
1747 read_buffer
= (char *) malloc (read_buffer_size
);
1752 struct Lisp_Subr
*sname
;
1755 sym
= intern (sname
->symbol_name
);
1756 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1759 #ifdef NOTDEF /* use fset in subr.el now */
1761 defalias (sname
, string
)
1762 struct Lisp_Subr
*sname
;
1766 sym
= intern (string
);
1767 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1771 /* Define an "integer variable"; a symbol whose value is forwarded
1772 to a C variable of type int. Sample call: */
1773 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1776 defvar_int (namestring
, address
)
1781 sym
= intern (namestring
);
1782 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1785 /* Similar but define a variable whose value is T if address contains 1,
1786 NIL if address contains 0 */
1789 defvar_bool (namestring
, address
)
1794 sym
= intern (namestring
);
1795 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1798 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1801 defvar_lisp (namestring
, address
)
1803 Lisp_Object
*address
;
1806 sym
= intern (namestring
);
1807 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1808 staticpro (address
);
1811 /* Similar but don't request gc-marking of the C variable.
1812 Used when that variable will be gc-marked for some other reason,
1813 since marking the same slot twice can cause trouble with strings. */
1816 defvar_lisp_nopro (namestring
, address
)
1818 Lisp_Object
*address
;
1821 sym
= intern (namestring
);
1822 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1827 /* Similar but define a variable whose value is the Lisp Object stored in
1828 the current buffer. address is the address of the slot in the buffer that is current now. */
1831 defvar_per_buffer (namestring
, address
, type
, doc
)
1833 Lisp_Object
*address
;
1839 extern struct buffer buffer_local_symbols
;
1841 sym
= intern (namestring
);
1842 offset
= (char *)address
- (char *)current_buffer
;
1844 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1845 (Lisp_Object
*) offset
);
1846 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1847 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1848 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1849 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1850 slot of buffer_local_flags */
1854 #endif /* standalone */
1860 /* Compute the default load-path. */
1862 normal
= PATH_LOADSEARCH
;
1863 Vload_path
= decode_env_path (0, normal
);
1865 if (NILP (Vpurify_flag
))
1866 normal
= PATH_LOADSEARCH
;
1868 normal
= PATH_DUMPLOADSEARCH
;
1870 /* In a dumped Emacs, we normally have to reset the value of
1871 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1872 uses ../lisp, instead of the path of the installed elisp
1873 libraries. However, if it appears that Vload_path was changed
1874 from the default before dumping, don't override that value. */
1877 Lisp_Object dump_path
;
1879 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1880 if (! NILP (Fequal (dump_path
, Vload_path
)))
1882 Vload_path
= decode_env_path (0, normal
);
1883 if (!NILP (Vinstallation_directory
))
1885 /* Add to the path the lisp subdir of the
1886 installation dir, if it exists. */
1887 Lisp_Object tem
, tem1
;
1888 tem
= Fexpand_file_name (build_string ("lisp"),
1889 Vinstallation_directory
);
1890 tem1
= Ffile_exists_p (tem
);
1893 if (NILP (Fmember (tem
, Vload_path
)))
1894 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1897 /* That dir doesn't exist, so add the build-time
1898 Lisp dirs instead. */
1899 Vload_path
= nconc2 (Vload_path
, dump_path
);
1904 Vload_path
= decode_env_path (0, normal
);
1907 /* Warn if dirs in the *standard* path don't exist. */
1909 Lisp_Object path_tail
;
1911 for (path_tail
= Vload_path
;
1913 path_tail
= XCONS (path_tail
)->cdr
)
1915 Lisp_Object dirfile
;
1916 dirfile
= Fcar (path_tail
);
1917 if (XTYPE (dirfile
) == Lisp_String
)
1919 dirfile
= Fdirectory_file_name (dirfile
);
1920 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1922 "Warning: Lisp directory `%s' does not exist.\n",
1923 XSTRING (Fcar (path_tail
))->data
);
1928 /* If the EMACSLOADPATH environment variable is set, use its value.
1929 This doesn't apply if we're dumping. */
1930 if (NILP (Vpurify_flag
)
1931 && egetenv ("EMACSLOADPATH"))
1932 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1936 load_in_progress
= 0;
1938 load_descriptor_list
= Qnil
;
1945 defsubr (&Sread_from_string
);
1947 defsubr (&Sintern_soft
);
1949 defsubr (&Seval_buffer
);
1950 defsubr (&Seval_region
);
1951 defsubr (&Sread_char
);
1952 defsubr (&Sread_char_exclusive
);
1953 defsubr (&Sread_event
);
1954 defsubr (&Sget_file_char
);
1955 defsubr (&Smapatoms
);
1957 DEFVAR_LISP ("obarray", &Vobarray
,
1958 "Symbol table for use by `intern' and `read'.\n\
1959 It is a vector whose length ought to be prime for best results.\n\
1960 The vector's contents don't make sense if examined from Lisp programs;\n\
1961 to find all the symbols in an obarray, use `mapatoms'.");
1963 DEFVAR_LISP ("values", &Vvalues
,
1964 "List of values of all expressions which were read, evaluated and printed.\n\
1965 Order is reverse chronological.");
1967 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1968 "Stream for read to get input from.\n\
1969 See documentation of `read' for possible values.");
1970 Vstandard_input
= Qt
;
1972 DEFVAR_LISP ("load-path", &Vload_path
,
1973 "*List of directories to search for files to load.\n\
1974 Each element is a string (directory name) or nil (try default directory).\n\
1975 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1976 otherwise to default specified by file `paths.h' when Emacs was built.");
1978 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1979 "Non-nil iff inside of `load'.");
1981 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1982 "An alist of expressions to be evalled when particular files are loaded.\n\
1983 Each element looks like (FILENAME FORMS...).\n\
1984 When `load' is run and the file-name argument is FILENAME,\n\
1985 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1986 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1987 with no directory specified, since that is how `load' is normally called.\n\
1988 An error in FORMS does not undo the load,\n\
1989 but does prevent execution of the rest of the FORMS.");
1990 Vafter_load_alist
= Qnil
;
1992 DEFVAR_LISP ("load-history", &Vload_history
,
1993 "Alist mapping source file names to symbols and features.\n\
1994 Each alist element is a list that starts with a file name,\n\
1995 except for one element (optional) that starts with nil and describes\n\
1996 definitions evaluated from buffers not visiting files.\n\
1997 The remaining elements of each list are symbols defined as functions\n\
1998 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1999 Vload_history
= Qnil
;
2001 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
2002 "Used for internal purposes by `load'.");
2003 Vcurrent_load_list
= Qnil
;
2005 load_descriptor_list
= Qnil
;
2006 staticpro (&load_descriptor_list
);
2008 Qcurrent_load_list
= intern ("current-load-list");
2009 staticpro (&Qcurrent_load_list
);
2011 Qstandard_input
= intern ("standard-input");
2012 staticpro (&Qstandard_input
);
2014 Qread_char
= intern ("read-char");
2015 staticpro (&Qread_char
);
2017 Qget_file_char
= intern ("get-file-char");
2018 staticpro (&Qget_file_char
);
2020 Qascii_character
= intern ("ascii-character");
2021 staticpro (&Qascii_character
);
2023 Qload
= intern ("load");