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 */
69 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
70 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
71 Lisp_Object Qascii_character
, Qload
;
73 extern Lisp_Object Qevent_symbol_element_mask
;
75 /* non-zero if inside `load' */
78 /* Search path for files to be loaded. */
79 Lisp_Object Vload_path
;
81 /* This is the user-visible association list that maps features to
82 lists of defs in their load files. */
83 Lisp_Object Vload_history
;
85 /* This is useud to build the load history. */
86 Lisp_Object Vcurrent_load_list
;
88 /* List of descriptors now open for Fload. */
89 static Lisp_Object load_descriptor_list
;
91 /* File for get_file_char to read from. Use by load */
92 static FILE *instream
;
94 /* When nonzero, read conses in pure space */
97 /* For use within read-from-string (this reader is non-reentrant!!) */
98 static int read_from_string_index
;
99 static int read_from_string_limit
;
101 /* Handle unreading and rereading of characters.
102 Write READCHAR to read a character,
103 UNREAD(c) to unread c to be read again. */
105 #define READCHAR readchar (readcharfun)
106 #define UNREAD(c) unreadchar (readcharfun, c)
109 readchar (readcharfun
)
110 Lisp_Object readcharfun
;
113 register struct buffer
*inbuffer
;
114 register int c
, mpos
;
116 if (XTYPE (readcharfun
) == Lisp_Buffer
)
118 inbuffer
= XBUFFER (readcharfun
);
120 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
122 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
123 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
127 if (XTYPE (readcharfun
) == Lisp_Marker
)
129 inbuffer
= XMARKER (readcharfun
)->buffer
;
131 mpos
= marker_position (readcharfun
);
133 if (mpos
> BUF_ZV (inbuffer
) - 1)
135 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
136 if (mpos
!= BUF_GPT (inbuffer
))
137 XMARKER (readcharfun
)->bufpos
++;
139 Fset_marker (readcharfun
, make_number (mpos
+ 1),
140 Fmarker_buffer (readcharfun
));
143 if (EQ (readcharfun
, Qget_file_char
))
147 /* Interrupted reads have been observed while reading over the network */
148 while (c
== EOF
&& ferror (instream
) && errno
== EINTR
)
157 if (XTYPE (readcharfun
) == Lisp_String
)
160 /* This used to be return of a conditional expression,
161 but that truncated -1 to a char on VMS. */
162 if (read_from_string_index
< read_from_string_limit
)
163 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
169 tem
= call0 (readcharfun
);
176 /* Unread the character C in the way appropriate for the stream READCHARFUN.
177 If the stream is a user function, call it with the char as argument. */
180 unreadchar (readcharfun
, c
)
181 Lisp_Object readcharfun
;
185 /* Don't back up the pointer if we're unreading the end-of-input mark,
186 since readchar didn't advance it when we read it. */
188 else if (XTYPE (readcharfun
) == Lisp_Buffer
)
190 if (XBUFFER (readcharfun
) == current_buffer
)
193 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
195 else if (XTYPE (readcharfun
) == Lisp_Marker
)
196 XMARKER (readcharfun
)->bufpos
--;
197 else if (XTYPE (readcharfun
) == Lisp_String
)
198 read_from_string_index
--;
199 else if (EQ (readcharfun
, Qget_file_char
))
200 ungetc (c
, instream
);
202 call1 (readcharfun
, make_number (c
));
205 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
207 /* get a character from the tty */
209 extern Lisp_Object
read_char ();
211 /* Read input events until we get one that's acceptable for our purposes.
213 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
214 until we get a character we like, and then stuffed into
217 If ASCII_REQUIRED is non-zero, we check function key events to see
218 if the unmodified version of the symbol has a Qascii_character
219 property, and use that character, if present.
221 If ERROR_NONASCII is non-zero, we signal an error if the input we
222 get isn't an ASCII character with modifiers. If it's zero but
223 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
226 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
227 int no_switch_frame
, ascii_required
, error_nonascii
;
230 return make_number (getchar ());
232 register Lisp_Object val
, delayed_switch_frame
;
234 delayed_switch_frame
= Qnil
;
236 /* Read until we get an acceptable event. */
238 val
= read_char (0, 0, 0, Qnil
, 0);
240 if (XTYPE (val
) == Lisp_Buffer
)
243 /* switch-frame events are put off until after the next ASCII
244 character. This is better than signalling an error just because
245 the last characters were typed to a separate minibuffer frame,
246 for example. Eventually, some code which can deal with
247 switch-frame events will read it and process it. */
249 && EVENT_HAS_PARAMETERS (val
)
250 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
252 delayed_switch_frame
= val
;
258 /* Convert certain symbols to their ASCII equivalents. */
259 if (XTYPE (val
) == Lisp_Symbol
)
261 Lisp_Object tem
, tem1
, tem2
;
262 tem
= Fget (val
, Qevent_symbol_element_mask
);
265 tem1
= Fget (Fcar (tem
), Qascii_character
);
266 /* Merge this symbol's modifier bits
267 with the ASCII equivalent of its basic code. */
269 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
273 /* If we don't have a character now, deal with it appropriately. */
274 if (XTYPE (val
) != Lisp_Int
)
278 Vunread_command_events
= Fcons (val
, Qnil
);
279 error ("Non-character input-event");
286 if (! NILP (delayed_switch_frame
))
287 unread_switch_frame
= delayed_switch_frame
;
293 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
294 "Read a character from the command input (keyboard or macro).\n\
295 It is returned as a number.\n\
296 If the user generates an event which is not a character (i.e. a mouse\n\
297 click or function key event), `read-char' signals an error. As an\n\
298 exception, switch-frame events are put off until non-ASCII events can\n\
300 If you want to read non-character events, or ignore them, call\n\
301 `read-event' or `read-char-exclusive' instead.")
304 return read_filtered_event (1, 1, 1);
307 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
308 "Read an event object from the input stream.")
311 return read_filtered_event (0, 0, 0);
314 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
315 "Read a character from the command input (keyboard or macro).\n\
316 It is returned as a number. Non character events are ignored.")
319 return read_filtered_event (1, 1, 0);
322 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
323 "Don't use this yourself.")
326 register Lisp_Object val
;
327 XSET (val
, Lisp_Int
, getc (instream
));
331 static void readevalloop ();
332 static Lisp_Object
load_unwind ();
333 static Lisp_Object
load_descriptor_unwind ();
335 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
336 "Execute a file of Lisp code named FILE.\n\
337 First try FILE with `.elc' appended, then try with `.el',\n\
338 then try FILE unmodified.\n\
339 This function searches the directories in `load-path'.\n\
340 If optional second arg NOERROR is non-nil,\n\
341 report no error if FILE doesn't exist.\n\
342 Print messages at start and end of loading unless\n\
343 optional third arg NOMESSAGE is non-nil.\n\
344 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
345 suffixes `.elc' or `.el' to the specified name FILE.\n\
346 Return t if file exists.")
347 (str
, noerror
, nomessage
, nosuffix
)
348 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
350 register FILE *stream
;
351 register int fd
= -1;
352 register Lisp_Object lispstream
;
354 int count
= specpdl_ptr
- specpdl
;
358 /* 1 means inhibit the message at the beginning. */
362 char *dosmode
= "rt";
365 CHECK_STRING (str
, 0);
366 str
= Fsubstitute_in_file_name (str
);
368 /* If file name is magic, call the handler. */
369 handler
= Ffind_file_name_handler (str
, Qload
);
371 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
373 /* Avoid weird lossage with null string as arg,
374 since it would try to load a directory as a Lisp file */
375 if (XSTRING (str
)->size
> 0)
378 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
387 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
393 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
402 stat ((char *)XSTRING (found
)->data
, &s1
);
403 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
404 result
= stat ((char *)XSTRING (found
)->data
, &s2
);
405 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
407 message ("Source file `%s' newer than byte-compiled file",
408 XSTRING (found
)->data
);
409 /* Don't immediately overwrite this message. */
413 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
418 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
420 stream
= fdopen (fd
, "r");
425 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
428 if (NILP (nomessage
) && !nomessage1
)
429 message ("Loading %s...", XSTRING (str
)->data
);
432 /* We may not be able to store STREAM itself as a Lisp_Object pointer
433 since that is guaranteed to work only for data that has been malloc'd.
434 So malloc a full-size pointer, and record the address of that pointer. */
435 ptr
= (FILE **) xmalloc (sizeof (FILE *));
437 XSET (lispstream
, Lisp_Internal_Stream
, (EMACS_INT
) ptr
);
438 record_unwind_protect (load_unwind
, lispstream
);
439 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
441 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
443 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
444 unbind_to (count
, Qnil
);
446 /* Run any load-hooks for this file. */
447 temp
= Fassoc (str
, Vafter_load_alist
);
449 Fprogn (Fcdr (temp
));
452 if (!noninteractive
&& NILP (nomessage
))
453 message ("Loading %s...done", XSTRING (str
)->data
);
458 load_unwind (stream
) /* used as unwind-protect function in load */
461 fclose (*(FILE **) XSTRING (stream
));
462 xfree (XPNTR (stream
));
463 if (--load_in_progress
< 0) load_in_progress
= 0;
468 load_descriptor_unwind (oldlist
)
471 load_descriptor_list
= oldlist
;
474 /* Close all descriptors in use for Floads.
475 This is used when starting a subprocess. */
481 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
482 close (XFASTINT (XCONS (tail
)->car
));
486 complete_filename_p (pathname
)
487 Lisp_Object pathname
;
489 register unsigned char *s
= XSTRING (pathname
)->data
;
497 #ifdef MSDOS /* MW, May 1993 */
498 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
503 /* Search for a file whose name is STR, looking in directories
504 in the Lisp list PATH, and trying suffixes from SUFFIX.
505 SUFFIX is a string containing possible suffixes separated by colons.
506 On success, returns a file descriptor. On failure, returns -1.
508 EXEC_ONLY nonzero means don't open the files,
509 just look for one that is executable. In this case,
510 returns 1 on success.
512 If STOREPTR is nonzero, it points to a slot where the name of
513 the file actually found should be stored as a Lisp string.
514 Nil is stored there on failure. */
517 openp (path
, str
, suffix
, storeptr
, exec_only
)
518 Lisp_Object path
, str
;
520 Lisp_Object
*storeptr
;
526 register char *fn
= buf
;
529 register Lisp_Object filename
;
537 if (complete_filename_p (str
))
540 for (; !NILP (path
); path
= Fcdr (path
))
544 filename
= Fexpand_file_name (str
, Fcar (path
));
545 if (!complete_filename_p (filename
))
546 /* If there are non-absolute elts in PATH (eg ".") */
547 /* Of course, this could conceivably lose if luser sets
548 default-directory to be something non-absolute... */
550 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
551 if (!complete_filename_p (filename
))
552 /* Give up on this path element! */
556 /* Calculate maximum size of any filename made from
557 this path element/specified file name and any possible suffix. */
558 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
559 if (fn_size
< want_size
)
560 fn
= (char *) alloca (fn_size
= 100 + want_size
);
564 /* Loop over suffixes. */
567 char *esuffix
= (char *) index (nsuffix
, ':');
568 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
570 /* Concatenate path element/specified name with the suffix. */
571 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
572 fn
[XSTRING (filename
)->size
] = 0;
573 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
574 strncat (fn
, nsuffix
, lsuffix
);
576 /* Ignore file if it's a directory. */
577 if (stat (fn
, &st
) >= 0
578 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
580 /* Check that we can access or open it. */
582 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
584 fd
= open (fn
, O_RDONLY
, 0);
588 /* We succeeded; return this descriptor and filename. */
590 *storeptr
= build_string (fn
);
595 /* Advance to next suffix. */
598 nsuffix
+= lsuffix
+ 1;
608 /* Merge the list we've accumulated of globals from the current input source
609 into the load_history variable. The details depend on whether
610 the source has an associated file name or not. */
613 build_load_history (stream
, source
)
617 register Lisp_Object tail
, prev
, newelt
;
618 register Lisp_Object tem
, tem2
;
619 register int foundit
, loading
;
621 /* Don't bother recording anything for preloaded files. */
622 if (!NILP (Vpurify_flag
))
625 loading
= stream
|| !NARROWED
;
627 tail
= Vload_history
;
634 /* Find the feature's previous assoc list... */
635 if (!NILP (Fequal (source
, Fcar (tem
))))
639 /* If we're loading, remove it. */
643 Vload_history
= Fcdr (tail
);
645 Fsetcdr (prev
, Fcdr (tail
));
648 /* Otherwise, cons on new symbols that are not already members. */
651 tem2
= Vcurrent_load_list
;
655 newelt
= Fcar (tem2
);
657 if (NILP (Fmemq (newelt
, tem
)))
658 Fsetcar (tail
, Fcons (Fcar (tem
),
659 Fcons (newelt
, Fcdr (tem
))));
672 /* If we're loading, cons the new assoc onto the front of load-history,
673 the most-recently-loaded position. Also do this if we didn't find
674 an existing member for the current source. */
675 if (loading
|| !foundit
)
676 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
681 unreadpure () /* Used as unwind-protect function in readevalloop */
688 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
689 Lisp_Object readcharfun
;
691 Lisp_Object sourcename
;
692 Lisp_Object (*evalfun
) ();
696 register Lisp_Object val
;
697 int count
= specpdl_ptr
- specpdl
;
699 struct buffer
*b
= 0;
701 if (BUFFERP (readcharfun
))
702 b
= XBUFFER (readcharfun
);
703 else if (MARKERP (readcharfun
))
704 b
= XMARKER (readcharfun
)->buffer
;
706 specbind (Qstandard_input
, readcharfun
);
707 specbind (Qcurrent_load_list
, Qnil
);
711 LOADHIST_ATTACH (sourcename
);
715 if (b
!= 0 && NILP (b
->name
))
716 error ("Reading from killed buffer");
722 while ((c
= READCHAR
) != '\n' && c
!= -1);
726 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
728 if (!NILP (Vpurify_flag
) && c
== '(')
730 int count1
= specpdl_ptr
- specpdl
;
731 record_unwind_protect (unreadpure
, Qnil
);
732 val
= read_list (-1, readcharfun
);
733 unbind_to (count1
, Qnil
);
738 val
= read0 (readcharfun
);
741 val
= (*evalfun
) (val
);
744 Vvalues
= Fcons (val
, Vvalues
);
745 if (EQ (Vstandard_output
, Qt
))
752 build_load_history (stream
, sourcename
);
755 unbind_to (count
, Qnil
);
760 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
761 "Execute the current buffer as Lisp code.\n\
762 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
763 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
764 PRINTFLAG controls printing of output:\n\
765 nil means discard it; anything else is stream for print.\n\
767 If there is no error, point does not move. If there is an error,\n\
768 point remains at the end of the last character read from the buffer.")
770 Lisp_Object bufname
, printflag
;
772 int count
= specpdl_ptr
- specpdl
;
773 Lisp_Object tem
, buf
;
776 buf
= Fcurrent_buffer ();
778 buf
= Fget_buffer (bufname
);
780 error ("No such buffer.");
782 if (NILP (printflag
))
786 specbind (Qstandard_output
, tem
);
787 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
788 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
789 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
790 unbind_to (count
, Qnil
);
796 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
797 "Execute the current buffer as Lisp code.\n\
798 Programs can pass argument PRINTFLAG which controls printing of output:\n\
799 nil means discard it; anything else is stream for print.\n\
801 If there is no error, point does not move. If there is an error,\n\
802 point remains at the end of the last character read from the buffer.")
804 Lisp_Object printflag
;
806 int count
= specpdl_ptr
- specpdl
;
807 Lisp_Object tem
, cbuf
;
809 cbuf
= Fcurrent_buffer ()
811 if (NILP (printflag
))
815 specbind (Qstandard_output
, tem
);
816 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
818 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
819 return unbind_to (count
, Qnil
);
823 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
824 "Execute the region as Lisp code.\n\
825 When called from programs, expects two arguments,\n\
826 giving starting and ending indices in the current buffer\n\
827 of the text to be executed.\n\
828 Programs can pass third argument PRINTFLAG which controls output:\n\
829 nil means discard it; anything else is stream for printing it.\n\
831 If there is no error, point does not move. If there is an error,\n\
832 point remains at the end of the last character read from the buffer.")
834 Lisp_Object b
, e
, printflag
;
836 int count
= specpdl_ptr
- specpdl
;
837 Lisp_Object tem
, cbuf
;
839 cbuf
= Fcurrent_buffer ();
841 if (NILP (printflag
))
845 specbind (Qstandard_output
, tem
);
847 if (NILP (printflag
))
848 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
849 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
851 /* This both uses b and checks its type. */
853 Fnarrow_to_region (make_number (BEGV
), e
);
854 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
856 return unbind_to (count
, Qnil
);
859 #endif /* standalone */
861 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
862 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
863 If STREAM is nil, use the value of `standard-input' (which see).\n\
864 STREAM or the value of `standard-input' may be:\n\
865 a buffer (read from point and advance it)\n\
866 a marker (read from where it points and advance it)\n\
867 a function (call it with no arguments for each character,\n\
868 call it with a char as argument to push a char back)\n\
869 a string (takes text from string, starting at the beginning)\n\
870 t (read text line using minibuffer and use it).")
872 Lisp_Object readcharfun
;
874 extern Lisp_Object
Fread_minibuffer ();
876 if (NILP (readcharfun
))
877 readcharfun
= Vstandard_input
;
878 if (EQ (readcharfun
, Qt
))
879 readcharfun
= Qread_char
;
882 if (EQ (readcharfun
, Qread_char
))
883 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
886 if (XTYPE (readcharfun
) == Lisp_String
)
887 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
889 return read0 (readcharfun
);
892 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
893 "Read one Lisp expression which is represented as text by STRING.\n\
894 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
895 START and END optionally delimit a substring of STRING from which to read;\n\
896 they default to 0 and (length STRING) respectively.")
898 Lisp_Object string
, start
, end
;
900 int startval
, endval
;
903 CHECK_STRING (string
,0);
906 endval
= XSTRING (string
)->size
;
908 { CHECK_NUMBER (end
,2);
910 if (endval
< 0 || endval
> XSTRING (string
)->size
)
911 args_out_of_range (string
, end
);
917 { CHECK_NUMBER (start
,1);
918 startval
= XINT (start
);
919 if (startval
< 0 || startval
> endval
)
920 args_out_of_range (string
, start
);
923 read_from_string_index
= startval
;
924 read_from_string_limit
= endval
;
926 tem
= read0 (string
);
927 return Fcons (tem
, make_number (read_from_string_index
));
930 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
934 Lisp_Object readcharfun
;
936 register Lisp_Object val
;
939 val
= read1 (readcharfun
);
940 if (XTYPE (val
) == Lisp_Internal
)
943 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
949 static int read_buffer_size
;
950 static char *read_buffer
;
953 read_escape (readcharfun
)
954 Lisp_Object readcharfun
;
956 register int c
= READCHAR
;
983 error ("Invalid escape character syntax");
986 c
= read_escape (readcharfun
);
987 return c
| meta_modifier
;
992 error ("Invalid escape character syntax");
995 c
= read_escape (readcharfun
);
996 return c
| shift_modifier
;
1001 error ("Invalid escape character syntax");
1004 c
= read_escape (readcharfun
);
1005 return c
| hyper_modifier
;
1010 error ("Invalid escape character syntax");
1013 c
= read_escape (readcharfun
);
1014 return c
| alt_modifier
;
1019 error ("Invalid escape character syntax");
1022 c
= read_escape (readcharfun
);
1023 return c
| super_modifier
;
1028 error ("Invalid escape character syntax");
1032 c
= read_escape (readcharfun
);
1033 if ((c
& 0177) == '?')
1035 /* ASCII control chars are made from letters (both cases),
1036 as well as the non-letters within 0100...0137. */
1037 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1038 return (c
& (037 | ~0177));
1039 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1040 return (c
& (037 | ~0177));
1042 return c
| ctrl_modifier
;
1052 /* An octal escape, as in ANSI C. */
1054 register int i
= c
- '0';
1055 register int count
= 0;
1058 if ((c
= READCHAR
) >= '0' && c
<= '7')
1073 /* A hex escape, as in ANSI C. */
1079 if (c
>= '0' && c
<= '9')
1084 else if ((c
>= 'a' && c
<= 'f')
1085 || (c
>= 'A' && c
<= 'F'))
1088 if (c
>= 'a' && c
<= 'f')
1109 register Lisp_Object readcharfun
;
1116 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1121 return read_list (0, readcharfun
);
1124 return read_vector (readcharfun
);
1129 register Lisp_Object val
;
1130 XSET (val
, Lisp_Internal
, c
);
1138 /* Accept compiled functions at read-time so that we don't have to
1139 build them using function calls. */
1141 tmp
= read_vector (readcharfun
);
1142 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1143 XVECTOR (tmp
)->contents
);
1145 #ifdef USE_TEXT_PROPERTIES
1149 struct gcpro gcpro1
;
1151 /* Read the string itself. */
1152 tmp
= read1 (readcharfun
);
1153 if (XTYPE (tmp
) != Lisp_String
)
1154 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1156 /* Read the intervals and their properties. */
1159 Lisp_Object beg
, end
, plist
;
1161 beg
= read1 (readcharfun
);
1162 if (XTYPE (beg
) == Lisp_Internal
)
1164 if (XINT (beg
) == ')')
1166 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1168 end
= read1 (readcharfun
);
1169 if (XTYPE (end
) == Lisp_Internal
)
1170 Fsignal (Qinvalid_read_syntax
,
1171 Fcons (make_string ("invalid string property list", 28), Qnil
));
1173 plist
= read1 (readcharfun
);
1174 if (XTYPE (plist
) == Lisp_Internal
)
1175 Fsignal (Qinvalid_read_syntax
,
1176 Fcons (make_string ("invalid string property list", 28), Qnil
));
1177 Fset_text_properties (beg
, end
, plist
, tmp
);
1184 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1187 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1192 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1197 register Lisp_Object val
;
1200 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1203 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1205 XSET (val
, Lisp_Int
, c
);
1212 register char *p
= read_buffer
;
1213 register char *end
= read_buffer
+ read_buffer_size
;
1217 while ((c
= READCHAR
) >= 0
1222 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1223 p
+= new - read_buffer
;
1224 read_buffer
+= new - read_buffer
;
1225 end
= read_buffer
+ read_buffer_size
;
1228 c
= read_escape (readcharfun
);
1229 /* c is -1 if \ newline has just been seen */
1232 if (p
== read_buffer
)
1237 /* Allow `\C- ' and `\C-?'. */
1238 if (c
== (CHAR_CTL
| ' '))
1240 else if (c
== (CHAR_CTL
| '?'))
1244 /* Move the meta bit to the right place for a string. */
1245 c
= (c
& ~CHAR_META
) | 0x80;
1247 error ("Invalid modifier in string");
1251 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1253 /* If purifying, and string starts with \ newline,
1254 return zero instead. This is for doc strings
1255 that we are really going to find in etc/DOC.nn.nn */
1256 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1257 return make_number (0);
1260 return make_pure_string (read_buffer
, p
- read_buffer
);
1262 return make_string (read_buffer
, p
- read_buffer
);
1267 #ifdef LISP_FLOAT_TYPE
1268 /* If a period is followed by a number, then we should read it
1269 as a floating point number. Otherwise, it denotes a dotted
1271 int next_char
= READCHAR
;
1274 if (! isdigit (next_char
))
1277 register Lisp_Object val
;
1278 XSET (val
, Lisp_Internal
, c
);
1282 /* Otherwise, we fall through! Note that the atom-reading loop
1283 below will now loop at least once, assuring that we will not
1284 try to UNREAD two characters in a row. */
1287 if (c
<= 040) goto retry
;
1289 register char *p
= read_buffer
;
1293 register char *end
= read_buffer
+ read_buffer_size
;
1296 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1297 || c
== '(' || c
== ')'
1298 #ifndef LISP_FLOAT_TYPE
1299 /* If we have floating-point support, then we need
1300 to allow <digits><dot><digits>. */
1302 #endif /* not LISP_FLOAT_TYPE */
1303 || c
== '[' || c
== ']' || c
== '#'
1308 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1309 p
+= new - read_buffer
;
1310 read_buffer
+= new - read_buffer
;
1311 end
= read_buffer
+ read_buffer_size
;
1324 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1325 p
+= new - read_buffer
;
1326 read_buffer
+= new - read_buffer
;
1327 /* end = read_buffer + read_buffer_size; */
1337 register Lisp_Object val
;
1339 if (*p1
== '+' || *p1
== '-') p1
++;
1340 /* Is it an integer? */
1343 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1344 #ifdef LISP_FLOAT_TYPE
1345 /* Integers can have trailing decimal points. */
1346 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1349 /* It is an integer. */
1351 #ifdef LISP_FLOAT_TYPE
1355 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1359 #ifdef LISP_FLOAT_TYPE
1360 if (isfloat_string (read_buffer
))
1361 return make_float (atof (read_buffer
));
1365 return intern (read_buffer
);
1370 #ifdef LISP_FLOAT_TYPE
1385 if (*cp
== '+' || *cp
== '-')
1391 while (isdigit (*cp
))
1402 while (isdigit (*cp
))
1410 if ((*cp
== '+') || (*cp
== '-'))
1416 while (isdigit (*cp
))
1420 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1421 || state
== (DOT_CHAR
|TRAIL_INT
)
1422 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1423 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1424 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1426 #endif /* LISP_FLOAT_TYPE */
1429 read_vector (readcharfun
)
1430 Lisp_Object readcharfun
;
1434 register Lisp_Object
*ptr
;
1435 register Lisp_Object tem
, vector
;
1436 register struct Lisp_Cons
*otem
;
1439 tem
= read_list (1, readcharfun
);
1440 len
= Flength (tem
);
1441 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1444 size
= XVECTOR (vector
)->size
;
1445 ptr
= XVECTOR (vector
)->contents
;
1446 for (i
= 0; i
< size
; i
++)
1448 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1456 /* flag = 1 means check for ] to terminate rather than ) and .
1457 flag = -1 means check for starting with defun
1458 and make structure pure. */
1461 read_list (flag
, readcharfun
)
1463 register Lisp_Object readcharfun
;
1465 /* -1 means check next element for defun,
1466 0 means don't check,
1467 1 means already checked and found defun. */
1468 int defunflag
= flag
< 0 ? -1 : 0;
1469 Lisp_Object val
, tail
;
1470 register Lisp_Object elt
, tem
;
1471 struct gcpro gcpro1
, gcpro2
;
1479 elt
= read1 (readcharfun
);
1481 if (XTYPE (elt
) == Lisp_Internal
)
1485 if (XINT (elt
) == ']')
1487 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1489 if (XINT (elt
) == ')')
1491 if (XINT (elt
) == '.')
1495 XCONS (tail
)->cdr
= read0 (readcharfun
);
1497 val
= read0 (readcharfun
);
1498 elt
= read1 (readcharfun
);
1500 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1502 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1504 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1506 tem
= (read_pure
&& flag
<= 0
1507 ? pure_cons (elt
, Qnil
)
1508 : Fcons (elt
, Qnil
));
1510 XCONS (tail
)->cdr
= tem
;
1515 defunflag
= EQ (elt
, Qdefun
);
1516 else if (defunflag
> 0)
1521 Lisp_Object Vobarray
;
1522 Lisp_Object initial_obarray
;
1525 check_obarray (obarray
)
1526 Lisp_Object obarray
;
1528 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1530 /* If Vobarray is now invalid, force it to be valid. */
1531 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1533 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1538 static int hash_string ();
1539 Lisp_Object
oblookup ();
1546 int len
= strlen (str
);
1547 Lisp_Object obarray
;
1550 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1551 obarray
= check_obarray (obarray
);
1552 tem
= oblookup (obarray
, str
, len
);
1553 if (XTYPE (tem
) == Lisp_Symbol
)
1555 return Fintern ((!NILP (Vpurify_flag
)
1556 ? make_pure_string (str
, len
)
1557 : make_string (str
, len
)),
1561 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1562 "Return the canonical symbol whose name is STRING.\n\
1563 If there is none, one is created by this function and returned.\n\
1564 A second optional argument specifies the obarray to use;\n\
1565 it defaults to the value of `obarray'.")
1567 Lisp_Object str
, obarray
;
1569 register Lisp_Object tem
, sym
, *ptr
;
1571 if (NILP (obarray
)) obarray
= Vobarray
;
1572 obarray
= check_obarray (obarray
);
1574 CHECK_STRING (str
, 0);
1576 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1577 if (XTYPE (tem
) != Lisp_Int
)
1580 if (!NILP (Vpurify_flag
))
1581 str
= Fpurecopy (str
);
1582 sym
= Fmake_symbol (str
);
1584 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1585 if (XTYPE (*ptr
) == Lisp_Symbol
)
1586 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1588 XSYMBOL (sym
)->next
= 0;
1593 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1594 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1595 A second optional argument specifies the obarray to use;\n\
1596 it defaults to the value of `obarray'.")
1598 Lisp_Object str
, obarray
;
1600 register Lisp_Object tem
;
1602 if (NILP (obarray
)) obarray
= Vobarray
;
1603 obarray
= check_obarray (obarray
);
1605 CHECK_STRING (str
, 0);
1607 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1608 if (XTYPE (tem
) != Lisp_Int
)
1614 oblookup (obarray
, ptr
, size
)
1615 Lisp_Object obarray
;
1621 register Lisp_Object tail
;
1622 Lisp_Object bucket
, tem
;
1624 if (XTYPE (obarray
) != Lisp_Vector
1625 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1627 obarray
= check_obarray (obarray
);
1628 obsize
= XVECTOR (obarray
)->size
;
1630 /* Combining next two lines breaks VMS C 2.3. */
1631 hash
= hash_string (ptr
, size
);
1633 bucket
= XVECTOR (obarray
)->contents
[hash
];
1634 if (XFASTINT (bucket
) == 0)
1636 else if (XTYPE (bucket
) != Lisp_Symbol
)
1637 error ("Bad data in guts of obarray"); /* Like CADR error message */
1638 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1640 if (XSYMBOL (tail
)->name
->size
== size
&&
1641 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1643 else if (XSYMBOL (tail
)->next
== 0)
1646 XSET (tem
, Lisp_Int
, hash
);
1651 hash_string (ptr
, len
)
1655 register unsigned char *p
= ptr
;
1656 register unsigned char *end
= p
+ len
;
1657 register unsigned char c
;
1658 register int hash
= 0;
1663 if (c
>= 0140) c
-= 40;
1664 hash
= ((hash
<<3) + (hash
>>28) + c
);
1666 return hash
& 07777777777;
1670 map_obarray (obarray
, fn
, arg
)
1671 Lisp_Object obarray
;
1676 register Lisp_Object tail
;
1677 CHECK_VECTOR (obarray
, 1);
1678 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1680 tail
= XVECTOR (obarray
)->contents
[i
];
1681 if (XFASTINT (tail
) != 0)
1685 if (XSYMBOL (tail
)->next
== 0)
1687 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1692 mapatoms_1 (sym
, function
)
1693 Lisp_Object sym
, function
;
1695 call1 (function
, sym
);
1698 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1699 "Call FUNCTION on every symbol in OBARRAY.\n\
1700 OBARRAY defaults to the value of `obarray'.")
1702 Lisp_Object function
, obarray
;
1706 if (NILP (obarray
)) obarray
= Vobarray
;
1707 obarray
= check_obarray (obarray
);
1709 map_obarray (obarray
, mapatoms_1
, function
);
1713 #define OBARRAY_SIZE 1511
1718 Lisp_Object oblength
;
1722 XFASTINT (oblength
) = OBARRAY_SIZE
;
1724 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1725 Vobarray
= Fmake_vector (oblength
, make_number (0));
1726 initial_obarray
= Vobarray
;
1727 staticpro (&initial_obarray
);
1728 /* Intern nil in the obarray */
1729 /* These locals are to kludge around a pyramid compiler bug. */
1730 hash
= hash_string ("nil", 3);
1731 /* Separate statement here to avoid VAXC bug. */
1732 hash
%= OBARRAY_SIZE
;
1733 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1736 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1737 XSYMBOL (Qnil
)->function
= Qunbound
;
1738 XSYMBOL (Qunbound
)->value
= Qunbound
;
1739 XSYMBOL (Qunbound
)->function
= Qunbound
;
1742 XSYMBOL (Qnil
)->value
= Qnil
;
1743 XSYMBOL (Qnil
)->plist
= Qnil
;
1744 XSYMBOL (Qt
)->value
= Qt
;
1746 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1749 Qvariable_documentation
= intern ("variable-documentation");
1751 read_buffer_size
= 100;
1752 read_buffer
= (char *) malloc (read_buffer_size
);
1757 struct Lisp_Subr
*sname
;
1760 sym
= intern (sname
->symbol_name
);
1761 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1764 #ifdef NOTDEF /* use fset in subr.el now */
1766 defalias (sname
, string
)
1767 struct Lisp_Subr
*sname
;
1771 sym
= intern (string
);
1772 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1776 /* Define an "integer variable"; a symbol whose value is forwarded
1777 to a C variable of type int. Sample call: */
1778 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1781 defvar_int (namestring
, address
)
1786 sym
= intern (namestring
);
1787 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1790 /* Similar but define a variable whose value is T if address contains 1,
1791 NIL if address contains 0 */
1794 defvar_bool (namestring
, address
)
1799 sym
= intern (namestring
);
1800 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1803 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1806 defvar_lisp (namestring
, address
)
1808 Lisp_Object
*address
;
1811 sym
= intern (namestring
);
1812 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1813 staticpro (address
);
1816 /* Similar but don't request gc-marking of the C variable.
1817 Used when that variable will be gc-marked for some other reason,
1818 since marking the same slot twice can cause trouble with strings. */
1821 defvar_lisp_nopro (namestring
, address
)
1823 Lisp_Object
*address
;
1826 sym
= intern (namestring
);
1827 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1832 /* Similar but define a variable whose value is the Lisp Object stored in
1833 the current buffer. address is the address of the slot in the buffer that is current now. */
1836 defvar_per_buffer (namestring
, address
, type
, doc
)
1838 Lisp_Object
*address
;
1844 extern struct buffer buffer_local_symbols
;
1846 sym
= intern (namestring
);
1847 offset
= (char *)address
- (char *)current_buffer
;
1849 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1850 (Lisp_Object
*) offset
);
1851 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1852 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1853 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1854 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1855 slot of buffer_local_flags */
1859 #endif /* standalone */
1865 /* Compute the default load-path. */
1867 normal
= PATH_LOADSEARCH
;
1868 Vload_path
= decode_env_path (0, normal
);
1870 if (NILP (Vpurify_flag
))
1871 normal
= PATH_LOADSEARCH
;
1873 normal
= PATH_DUMPLOADSEARCH
;
1875 /* In a dumped Emacs, we normally have to reset the value of
1876 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1877 uses ../lisp, instead of the path of the installed elisp
1878 libraries. However, if it appears that Vload_path was changed
1879 from the default before dumping, don't override that value. */
1882 Lisp_Object dump_path
;
1884 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1885 if (! NILP (Fequal (dump_path
, Vload_path
)))
1887 Vload_path
= decode_env_path (0, normal
);
1888 if (!NILP (Vinstallation_directory
))
1890 /* Add to the path the lisp subdir of the
1891 installation dir, if it exists. */
1892 Lisp_Object tem
, tem1
;
1893 tem
= Fexpand_file_name (build_string ("lisp"),
1894 Vinstallation_directory
);
1895 tem1
= Ffile_exists_p (tem
);
1898 if (NILP (Fmember (tem
, Vload_path
)))
1899 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1902 /* That dir doesn't exist, so add the build-time
1903 Lisp dirs instead. */
1904 Vload_path
= nconc2 (Vload_path
, dump_path
);
1909 Vload_path
= decode_env_path (0, normal
);
1912 /* Warn if dirs in the *standard* path don't exist. */
1914 Lisp_Object path_tail
;
1916 for (path_tail
= Vload_path
;
1918 path_tail
= XCONS (path_tail
)->cdr
)
1920 Lisp_Object dirfile
;
1921 dirfile
= Fcar (path_tail
);
1922 if (XTYPE (dirfile
) == Lisp_String
)
1924 dirfile
= Fdirectory_file_name (dirfile
);
1925 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1927 "Warning: Lisp directory `%s' does not exist.\n",
1928 XSTRING (Fcar (path_tail
))->data
);
1933 /* If the EMACSLOADPATH environment variable is set, use its value.
1934 This doesn't apply if we're dumping. */
1935 if (NILP (Vpurify_flag
)
1936 && egetenv ("EMACSLOADPATH"))
1937 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1941 load_in_progress
= 0;
1943 load_descriptor_list
= Qnil
;
1950 defsubr (&Sread_from_string
);
1952 defsubr (&Sintern_soft
);
1954 defsubr (&Seval_buffer
);
1955 defsubr (&Seval_region
);
1956 defsubr (&Sread_char
);
1957 defsubr (&Sread_char_exclusive
);
1958 defsubr (&Sread_event
);
1959 defsubr (&Sget_file_char
);
1960 defsubr (&Smapatoms
);
1962 DEFVAR_LISP ("obarray", &Vobarray
,
1963 "Symbol table for use by `intern' and `read'.\n\
1964 It is a vector whose length ought to be prime for best results.\n\
1965 The vector's contents don't make sense if examined from Lisp programs;\n\
1966 to find all the symbols in an obarray, use `mapatoms'.");
1968 DEFVAR_LISP ("values", &Vvalues
,
1969 "List of values of all expressions which were read, evaluated and printed.\n\
1970 Order is reverse chronological.");
1972 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1973 "Stream for read to get input from.\n\
1974 See documentation of `read' for possible values.");
1975 Vstandard_input
= Qt
;
1977 DEFVAR_LISP ("load-path", &Vload_path
,
1978 "*List of directories to search for files to load.\n\
1979 Each element is a string (directory name) or nil (try default directory).\n\
1980 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1981 otherwise to default specified by file `paths.h' when Emacs was built.");
1983 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1984 "Non-nil iff inside of `load'.");
1986 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1987 "An alist of expressions to be evalled when particular files are loaded.\n\
1988 Each element looks like (FILENAME FORMS...).\n\
1989 When `load' is run and the file-name argument is FILENAME,\n\
1990 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1991 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1992 with no directory specified, since that is how `load' is normally called.\n\
1993 An error in FORMS does not undo the load,\n\
1994 but does prevent execution of the rest of the FORMS.");
1995 Vafter_load_alist
= Qnil
;
1997 DEFVAR_LISP ("load-history", &Vload_history
,
1998 "Alist mapping source file names to symbols and features.\n\
1999 Each alist element is a list that starts with a file name,\n\
2000 except for one element (optional) that starts with nil and describes\n\
2001 definitions evaluated from buffers not visiting files.\n\
2002 The remaining elements of each list are symbols defined as functions\n\
2003 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
2004 Vload_history
= Qnil
;
2006 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
2007 "Used for internal purposes by `load'.");
2008 Vcurrent_load_list
= Qnil
;
2010 load_descriptor_list
= Qnil
;
2011 staticpro (&load_descriptor_list
);
2013 Qcurrent_load_list
= intern ("current-load-list");
2014 staticpro (&Qcurrent_load_list
);
2016 Qstandard_input
= intern ("standard-input");
2017 staticpro (&Qstandard_input
);
2019 Qread_char
= intern ("read-char");
2020 staticpro (&Qread_char
);
2022 Qget_file_char
= intern ("get-file-char");
2023 staticpro (&Qget_file_char
);
2025 Qascii_character
= intern ("ascii-character");
2026 staticpro (&Qascii_character
);
2028 Qload
= intern ("load");