1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989,
3 1993 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include <sys/types.h>
35 #include "termhooks.h"
39 #include <sys/inode.h>
46 #ifdef LISP_FLOAT_TYPE
51 #endif /* LISP_FLOAT_TYPE */
53 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
54 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
55 Lisp_Object Qascii_character
, Qload
;
57 extern Lisp_Object Qevent_symbol_element_mask
;
59 /* non-zero if inside `load' */
62 /* Search path for files to be loaded. */
63 Lisp_Object Vload_path
;
65 /* This is the user-visible association list that maps features to
66 lists of defs in their load files. */
67 Lisp_Object Vload_history
;
69 /* This is useud to build the load history. */
70 Lisp_Object Vcurrent_load_list
;
72 /* File for get_file_char to read from. Use by load */
73 static FILE *instream
;
75 /* When nonzero, read conses in pure space */
78 /* For use within read-from-string (this reader is non-reentrant!!) */
79 static int read_from_string_index
;
80 static int read_from_string_limit
;
82 /* Handle unreading and rereading of characters.
83 Write READCHAR to read a character,
84 UNREAD(c) to unread c to be read again. */
86 #define READCHAR readchar (readcharfun)
87 #define UNREAD(c) unreadchar (readcharfun, c)
90 readchar (readcharfun
)
91 Lisp_Object readcharfun
;
94 register struct buffer
*inbuffer
;
97 if (XTYPE (readcharfun
) == Lisp_Buffer
)
99 inbuffer
= XBUFFER (readcharfun
);
101 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
103 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
104 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
108 if (XTYPE (readcharfun
) == Lisp_Marker
)
110 inbuffer
= XMARKER (readcharfun
)->buffer
;
112 mpos
= marker_position (readcharfun
);
114 if (mpos
> BUF_ZV (inbuffer
) - 1)
116 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
117 if (mpos
!= BUF_GPT (inbuffer
))
118 XMARKER (readcharfun
)->bufpos
++;
120 Fset_marker (readcharfun
, make_number (mpos
+ 1),
121 Fmarker_buffer (readcharfun
));
124 if (EQ (readcharfun
, Qget_file_char
))
125 return getc (instream
);
127 if (XTYPE (readcharfun
) == Lisp_String
)
130 /* This used to be return of a conditional expression,
131 but that truncated -1 to a char on VMS. */
132 if (read_from_string_index
< read_from_string_limit
)
133 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
139 tem
= call0 (readcharfun
);
146 /* Unread the character C in the way appropriate for the stream READCHARFUN.
147 If the stream is a user function, call it with the char as argument. */
150 unreadchar (readcharfun
, c
)
151 Lisp_Object readcharfun
;
154 if (XTYPE (readcharfun
) == Lisp_Buffer
)
156 if (XBUFFER (readcharfun
) == current_buffer
)
159 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
161 else if (XTYPE (readcharfun
) == Lisp_Marker
)
162 XMARKER (readcharfun
)->bufpos
--;
163 else if (XTYPE (readcharfun
) == Lisp_String
)
164 read_from_string_index
--;
165 else if (EQ (readcharfun
, Qget_file_char
))
166 ungetc (c
, instream
);
168 call1 (readcharfun
, make_number (c
));
171 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
173 /* get a character from the tty */
175 extern Lisp_Object
read_char ();
177 /* Read input events until we get one that's acceptable for our purposes.
179 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
180 until we get a character we like, and then stuffed into
183 If ASCII_REQUIRED is non-zero, we check function key events to see
184 if the unmodified version of the symbol has a Qascii_character
185 property, and use that character, if present.
187 If ERROR_NONASCII is non-zero, we signal an error if the input we
188 get isn't an ASCII character with modifiers. If it's zero but
189 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
192 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
193 int no_switch_frame
, ascii_required
, error_nonascii
;
196 return make_number (getchar ());
198 register Lisp_Object val
;
199 register Lisp_Object delayed_switch_frame
= Qnil
;
201 /* Read until we get an acceptable event. */
203 val
= read_char (0, 0, 0, Qnil
, 0);
205 /* switch-frame events are put off until after the next ASCII
206 character. This is better than signalling an error just because
207 the last characters were typed to a separate minibuffer frame,
208 for example. Eventually, some code which can deal with
209 switch-frame events will read it and process it. */
211 && EVENT_HAS_PARAMETERS (val
)
212 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
214 delayed_switch_frame
= val
;
220 /* Convert certain symbols to their ASCII equivalents. */
221 if (XTYPE (val
) == Lisp_Symbol
)
223 Lisp_Object tem
, tem1
, tem2
;
224 tem
= Fget (val
, Qevent_symbol_element_mask
);
227 tem1
= Fget (Fcar (tem
), Qascii_character
);
228 /* Merge this symbol's modifier bits
229 with the ASCII equivalent of its basic code. */
231 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
235 /* If we don't have a character now, deal with it appropriately. */
236 if (XTYPE (val
) != Lisp_Int
)
240 unread_command_events
= Fcons (val
, Qnil
);
241 error ("Non-character input-event");
248 if (! NILP (delayed_switch_frame
))
249 unread_switch_frame
= delayed_switch_frame
;
255 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
256 "Read a character from the command input (keyboard or macro).\n\
257 It is returned as a number.\n\
258 If the user generates an event which is not a character (i.e. a mouse\n\
259 click or function key event), `read-char' signals an error. As an\n\
260 exception, switch-frame events are put off until non-ASCII events can\n\
262 If you want to read non-character events, or ignore them, call\n\
263 `read-event' or `read-char-exclusive' instead.")
266 return read_filtered_event (1, 1, 1);
269 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
270 "Read an event object from the input stream.")
273 return read_filtered_event (0, 0, 0);
276 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
277 "Read a character from the command input (keyboard or macro).\n\
278 It is returned as a number. Non character events are ignored.")
281 return read_filtered_event (1, 1, 0);
284 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
285 "Don't use this yourself.")
288 register Lisp_Object val
;
289 XSET (val
, Lisp_Int
, getc (instream
));
293 static void readevalloop ();
294 static Lisp_Object
load_unwind ();
296 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
297 "Execute a file of Lisp code named FILE.\n\
298 First try FILE with `.elc' appended, then try with `.el',\n\
299 then try FILE unmodified.\n\
300 This function searches the directories in `load-path'.\n\
301 If optional second arg NOERROR is non-nil,\n\
302 report no error if FILE doesn't exist.\n\
303 Print messages at start and end of loading unless\n\
304 optional third arg NOMESSAGE is non-nil.\n\
305 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
306 suffixes `.elc' or `.el' to the specified name FILE.\n\
307 Return t if file exists.")
308 (str
, noerror
, nomessage
, nosuffix
)
309 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
311 register FILE *stream
;
312 register int fd
= -1;
313 register Lisp_Object lispstream
;
315 int count
= specpdl_ptr
- specpdl
;
319 /* 1 means inhibit the message at the beginning. */
323 CHECK_STRING (str
, 0);
324 str
= Fsubstitute_in_file_name (str
);
326 /* If file name is magic, call the handler. */
327 handler
= Ffind_file_name_handler (str
);
329 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
331 /* Avoid weird lossage with null string as arg,
332 since it would try to load a directory as a Lisp file */
333 if (XSTRING (str
)->size
> 0)
335 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
343 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
349 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
355 stat (XSTRING (found
)->data
, &s1
);
356 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
357 result
= stat (XSTRING (found
)->data
, &s2
);
358 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
360 message ("Source file `%s' newer than byte-compiled file",
361 XSTRING (found
)->data
);
362 /* Don't immediately overwrite this message. */
366 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
369 stream
= fdopen (fd
, "r");
373 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
376 if (NILP (nomessage
) && !nomessage1
)
377 message ("Loading %s...", XSTRING (str
)->data
);
380 /* We may not be able to store STREAM itself as a Lisp_Object pointer
381 since that is guaranteed to work only for data that has been malloc'd.
382 So malloc a full-size pointer, and record the address of that pointer. */
383 ptr
= (FILE **) xmalloc (sizeof (FILE *));
385 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
386 record_unwind_protect (load_unwind
, lispstream
);
388 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
389 unbind_to (count
, Qnil
);
391 /* Run any load-hooks for this file. */
392 temp
= Fassoc (str
, Vafter_load_alist
);
394 Fprogn (Fcdr (temp
));
397 if (!noninteractive
&& NILP (nomessage
))
398 message ("Loading %s...done", XSTRING (str
)->data
);
403 load_unwind (stream
) /* used as unwind-protect function in load */
406 fclose (*(FILE **) XSTRING (stream
));
407 xfree (XPNTR (stream
));
408 if (--load_in_progress
< 0) load_in_progress
= 0;
414 complete_filename_p (pathname
)
415 Lisp_Object pathname
;
417 register unsigned char *s
= XSTRING (pathname
)->data
;
428 /* Search for a file whose name is STR, looking in directories
429 in the Lisp list PATH, and trying suffixes from SUFFIX.
430 SUFFIX is a string containing possible suffixes separated by colons.
431 On success, returns a file descriptor. On failure, returns -1.
433 EXEC_ONLY nonzero means don't open the files,
434 just look for one that is executable. In this case,
435 returns 1 on success.
437 If STOREPTR is nonzero, it points to a slot where the name of
438 the file actually found should be stored as a Lisp string.
439 Nil is stored there on failure. */
442 openp (path
, str
, suffix
, storeptr
, exec_only
)
443 Lisp_Object path
, str
;
445 Lisp_Object
*storeptr
;
451 register char *fn
= buf
;
454 register Lisp_Object filename
;
460 if (complete_filename_p (str
))
463 for (; !NILP (path
); path
= Fcdr (path
))
467 filename
= Fexpand_file_name (str
, Fcar (path
));
468 if (!complete_filename_p (filename
))
469 /* If there are non-absolute elts in PATH (eg ".") */
470 /* Of course, this could conceivably lose if luser sets
471 default-directory to be something non-absolute... */
473 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
474 if (!complete_filename_p (filename
))
475 /* Give up on this path element! */
479 /* Calculate maximum size of any filename made from
480 this path element/specified file name and any possible suffix. */
481 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
482 if (fn_size
< want_size
)
483 fn
= (char *) alloca (fn_size
= 100 + want_size
);
487 /* Loop over suffixes. */
490 char *esuffix
= (char *) index (nsuffix
, ':');
491 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
493 /* Concatenate path element/specified name with the suffix. */
494 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
495 fn
[XSTRING (filename
)->size
] = 0;
496 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
497 strncat (fn
, nsuffix
, lsuffix
);
499 /* Ignore file if it's a directory. */
500 if (stat (fn
, &st
) >= 0
501 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
503 /* Check that we can access or open it. */
505 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
507 fd
= open (fn
, 0, 0);
511 /* We succeeded; return this descriptor and filename. */
513 *storeptr
= build_string (fn
);
518 /* Advance to next suffix. */
521 nsuffix
+= lsuffix
+ 1;
523 if (absolute
) return -1;
530 /* Merge the list we've accumulated of globals from the current input source
531 into the load_history variable. The details depend on whether
532 the source has an associated file name or not. */
535 build_load_history (stream
, source
)
539 register Lisp_Object tail
, prev
, newelt
;
540 register Lisp_Object tem
, tem2
;
541 register int foundit
, loading
;
543 /* Don't bother recording anything for preloaded files. */
544 if (!NILP (Vpurify_flag
))
547 loading
= stream
|| !NARROWED
;
549 tail
= Vload_history
;
556 /* Find the feature's previous assoc list... */
557 if (!NILP (Fequal (source
, Fcar (tem
))))
561 /* If we're loading, remove it. */
565 Vload_history
= Fcdr (tail
);
567 Fsetcdr (prev
, Fcdr (tail
));
570 /* Otherwise, cons on new symbols that are not already members. */
573 tem2
= Vcurrent_load_list
;
577 newelt
= Fcar (tem2
);
579 if (NILP (Fmemq (newelt
, tem
)))
580 Fsetcar (tail
, Fcons (Fcar (tem
),
581 Fcons (newelt
, Fcdr (tem
))));
594 /* If we're loading, cons the new assoc onto the front of load-history,
595 the most-recently-loaded position. Also do this if we didn't find
596 an existing member for the current source. */
597 if (loading
|| !foundit
)
598 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
603 unreadpure () /* Used as unwind-protect function in readevalloop */
610 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
611 Lisp_Object readcharfun
;
613 Lisp_Object sourcename
;
614 Lisp_Object (*evalfun
) ();
618 register Lisp_Object val
;
619 int count
= specpdl_ptr
- specpdl
;
622 specbind (Qstandard_input
, readcharfun
);
623 specbind (Qcurrent_load_list
, Qnil
);
627 LOADHIST_ATTACH (sourcename
);
635 while ((c
= READCHAR
) != '\n' && c
!= -1);
639 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
641 if (!NILP (Vpurify_flag
) && c
== '(')
643 record_unwind_protect (unreadpure
, Qnil
);
644 val
= read_list (-1, readcharfun
);
645 unbind_to (count
+ 1, Qnil
);
650 val
= read0 (readcharfun
);
653 val
= (*evalfun
) (val
);
656 Vvalues
= Fcons (val
, Vvalues
);
657 if (EQ (Vstandard_output
, Qt
))
664 build_load_history (stream
, sourcename
);
667 unbind_to (count
, Qnil
);
672 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
673 "Execute the current buffer as Lisp code.\n\
674 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
675 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
676 PRINTFLAG controls printing of output:\n\
677 nil means discard it; anything else is stream for print.\n\
679 If there is no error, point does not move. If there is an error,\n\
680 point remains at the end of the last character read from the buffer.")
682 Lisp_Object bufname
, printflag
;
684 int count
= specpdl_ptr
- specpdl
;
685 Lisp_Object tem
, buf
;
688 buf
= Fcurrent_buffer ();
690 buf
= Fget_buffer (bufname
);
692 error ("No such buffer.");
694 if (NILP (printflag
))
698 specbind (Qstandard_output
, tem
);
699 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
700 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
701 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
702 unbind_to (count
, Qnil
);
708 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
709 "Execute the current buffer as Lisp code.\n\
710 Programs can pass argument PRINTFLAG which controls printing of output:\n\
711 nil means discard it; anything else is stream for print.\n\
713 If there is no error, point does not move. If there is an error,\n\
714 point remains at the end of the last character read from the buffer.")
716 Lisp_Object printflag
;
718 int count
= specpdl_ptr
- specpdl
;
719 Lisp_Object tem
, cbuf
;
721 cbuf
= Fcurrent_buffer ()
723 if (NILP (printflag
))
727 specbind (Qstandard_output
, tem
);
728 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
730 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
731 return unbind_to (count
, Qnil
);
735 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
736 "Execute the region as Lisp code.\n\
737 When called from programs, expects two arguments,\n\
738 giving starting and ending indices in the current buffer\n\
739 of the text to be executed.\n\
740 Programs can pass third argument PRINTFLAG which controls output:\n\
741 nil means discard it; anything else is stream for printing it.\n\
743 If there is no error, point does not move. If there is an error,\n\
744 point remains at the end of the last character read from the buffer.")
746 Lisp_Object b
, e
, printflag
;
748 int count
= specpdl_ptr
- specpdl
;
749 Lisp_Object tem
, cbuf
;
751 cbuf
= Fcurrent_buffer ();
753 if (NILP (printflag
))
757 specbind (Qstandard_output
, tem
);
759 if (NILP (printflag
))
760 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
761 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
763 /* This both uses b and checks its type. */
765 Fnarrow_to_region (make_number (BEGV
), e
);
766 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
768 return unbind_to (count
, Qnil
);
771 #endif /* standalone */
773 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
774 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
775 If STREAM is nil, use the value of `standard-input' (which see).\n\
776 STREAM or the value of `standard-input' may be:\n\
777 a buffer (read from point and advance it)\n\
778 a marker (read from where it points and advance it)\n\
779 a function (call it with no arguments for each character,\n\
780 call it with a char as argument to push a char back)\n\
781 a string (takes text from string, starting at the beginning)\n\
782 t (read text line using minibuffer and use it).")
784 Lisp_Object readcharfun
;
786 extern Lisp_Object
Fread_minibuffer ();
788 if (NILP (readcharfun
))
789 readcharfun
= Vstandard_input
;
790 if (EQ (readcharfun
, Qt
))
791 readcharfun
= Qread_char
;
794 if (EQ (readcharfun
, Qread_char
))
795 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
798 if (XTYPE (readcharfun
) == Lisp_String
)
799 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
801 return read0 (readcharfun
);
804 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
805 "Read one Lisp expression which is represented as text by STRING.\n\
806 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
807 START and END optionally delimit a substring of STRING from which to read;\n\
808 they default to 0 and (length STRING) respectively.")
810 Lisp_Object string
, start
, end
;
812 int startval
, endval
;
815 CHECK_STRING (string
,0);
818 endval
= XSTRING (string
)->size
;
820 { CHECK_NUMBER (end
,2);
822 if (endval
< 0 || endval
> XSTRING (string
)->size
)
823 args_out_of_range (string
, end
);
829 { CHECK_NUMBER (start
,1);
830 startval
= XINT (start
);
831 if (startval
< 0 || startval
> endval
)
832 args_out_of_range (string
, start
);
835 read_from_string_index
= startval
;
836 read_from_string_limit
= endval
;
838 tem
= read0 (string
);
839 return Fcons (tem
, make_number (read_from_string_index
));
842 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
846 Lisp_Object readcharfun
;
848 register Lisp_Object val
;
851 val
= read1 (readcharfun
);
852 if (XTYPE (val
) == Lisp_Internal
)
855 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
861 static int read_buffer_size
;
862 static char *read_buffer
;
865 read_escape (readcharfun
)
866 Lisp_Object readcharfun
;
868 register int c
= READCHAR
;
895 error ("Invalid escape character syntax");
898 c
= read_escape (readcharfun
);
899 return c
| meta_modifier
;
904 error ("Invalid escape character syntax");
907 c
= read_escape (readcharfun
);
908 return c
| shift_modifier
;
913 error ("Invalid escape character syntax");
916 c
= read_escape (readcharfun
);
917 return c
| hyper_modifier
;
922 error ("Invalid escape character syntax");
925 c
= read_escape (readcharfun
);
926 return c
| alt_modifier
;
931 error ("Invalid escape character syntax");
934 c
= read_escape (readcharfun
);
935 return c
| super_modifier
;
940 error ("Invalid escape character syntax");
944 c
= read_escape (readcharfun
);
945 if ((c
& 0177) == '?')
947 /* ASCII control chars are made from letters (both cases),
948 as well as the non-letters within 0100...0137. */
949 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
950 return (c
& (037 | ~0177));
951 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
952 return (c
& (037 | ~0177));
954 return c
| ctrl_modifier
;
964 /* An octal escape, as in ANSI C. */
966 register int i
= c
- '0';
967 register int count
= 0;
970 if ((c
= READCHAR
) >= '0' && c
<= '7')
985 /* A hex escape, as in ANSI C. */
991 if (c
>= '0' && c
<= '9')
996 else if ((c
>= 'a' && c
<= 'f')
997 || (c
>= 'A' && c
<= 'F'))
1000 if (c
>= 'a' && c
<= 'f')
1021 register Lisp_Object readcharfun
;
1028 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1033 return read_list (0, readcharfun
);
1036 return read_vector (readcharfun
);
1041 register Lisp_Object val
;
1042 XSET (val
, Lisp_Internal
, c
);
1050 /* Accept compiled functions at read-time so that we don't have to
1051 build them using function calls. */
1053 tmp
= read_vector (readcharfun
);
1054 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1055 XVECTOR (tmp
)->contents
);
1057 #ifdef USE_TEXT_PROPERTIES
1061 struct gcpro gcpro1
;
1063 /* Read the string itself. */
1064 tmp
= read1 (readcharfun
);
1065 if (XTYPE (tmp
) != Lisp_String
)
1066 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1068 /* Read the intervals and their properties. */
1071 Lisp_Object beg
, end
, plist
;
1073 beg
= read1 (readcharfun
);
1074 if (XTYPE (beg
) == Lisp_Internal
)
1076 if (XINT (beg
) == ')')
1078 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1080 end
= read1 (readcharfun
);
1081 if (XTYPE (end
) == Lisp_Internal
)
1082 Fsignal (Qinvalid_read_syntax
,
1083 Fcons (make_string ("invalid string property list", 28), Qnil
));
1085 plist
= read1 (readcharfun
);
1086 if (XTYPE (plist
) == Lisp_Internal
)
1087 Fsignal (Qinvalid_read_syntax
,
1088 Fcons (make_string ("invalid string property list", 28), Qnil
));
1089 Fset_text_properties (beg
, end
, plist
, tmp
);
1096 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1099 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1104 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1109 register Lisp_Object val
;
1112 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1115 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1117 XSET (val
, Lisp_Int
, c
);
1124 register char *p
= read_buffer
;
1125 register char *end
= read_buffer
+ read_buffer_size
;
1129 while ((c
= READCHAR
) >= 0
1134 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1135 p
+= new - read_buffer
;
1136 read_buffer
+= new - read_buffer
;
1137 end
= read_buffer
+ read_buffer_size
;
1140 c
= read_escape (readcharfun
);
1141 /* c is -1 if \ newline has just been seen */
1144 if (p
== read_buffer
)
1147 else if (c
& CHAR_META
)
1148 /* Move the meta bit to the right place for a string. */
1149 *p
++ = (c
& ~CHAR_META
) | 0x80;
1153 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1155 /* If purifying, and string starts with \ newline,
1156 return zero instead. This is for doc strings
1157 that we are really going to find in etc/DOC.nn.nn */
1158 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1159 return make_number (0);
1162 return make_pure_string (read_buffer
, p
- read_buffer
);
1164 return make_string (read_buffer
, p
- read_buffer
);
1169 #ifdef LISP_FLOAT_TYPE
1170 /* If a period is followed by a number, then we should read it
1171 as a floating point number. Otherwise, it denotes a dotted
1173 int next_char
= READCHAR
;
1176 if (! isdigit (next_char
))
1179 register Lisp_Object val
;
1180 XSET (val
, Lisp_Internal
, c
);
1184 /* Otherwise, we fall through! Note that the atom-reading loop
1185 below will now loop at least once, assuring that we will not
1186 try to UNREAD two characters in a row. */
1189 if (c
<= 040) goto retry
;
1191 register char *p
= read_buffer
;
1195 register char *end
= read_buffer
+ read_buffer_size
;
1198 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1199 || c
== '(' || c
== ')'
1200 #ifndef LISP_FLOAT_TYPE
1201 /* If we have floating-point support, then we need
1202 to allow <digits><dot><digits>. */
1204 #endif /* not LISP_FLOAT_TYPE */
1205 || c
== '[' || c
== ']' || c
== '#'
1210 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1211 p
+= new - read_buffer
;
1212 read_buffer
+= new - read_buffer
;
1213 end
= read_buffer
+ read_buffer_size
;
1226 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1227 p
+= new - read_buffer
;
1228 read_buffer
+= new - read_buffer
;
1229 /* end = read_buffer + read_buffer_size; */
1239 register Lisp_Object val
;
1241 if (*p1
== '+' || *p1
== '-') p1
++;
1242 /* Is it an integer? */
1245 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1246 #ifdef LISP_FLOAT_TYPE
1247 /* Integers can have trailing decimal points. */
1248 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1251 /* It is an integer. */
1253 #ifdef LISP_FLOAT_TYPE
1257 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1261 #ifdef LISP_FLOAT_TYPE
1262 if (isfloat_string (read_buffer
))
1263 return make_float (atof (read_buffer
));
1267 return intern (read_buffer
);
1272 #ifdef LISP_FLOAT_TYPE
1287 if (*cp
== '+' || *cp
== '-')
1293 while (isdigit (*cp
))
1304 while (isdigit (*cp
))
1312 if ((*cp
== '+') || (*cp
== '-'))
1318 while (isdigit (*cp
))
1322 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1323 || state
== (DOT_CHAR
|TRAIL_INT
)
1324 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1325 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1326 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1328 #endif /* LISP_FLOAT_TYPE */
1331 read_vector (readcharfun
)
1332 Lisp_Object readcharfun
;
1336 register Lisp_Object
*ptr
;
1337 register Lisp_Object tem
, vector
;
1338 register struct Lisp_Cons
*otem
;
1341 tem
= read_list (1, readcharfun
);
1342 len
= Flength (tem
);
1343 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1346 size
= XVECTOR (vector
)->size
;
1347 ptr
= XVECTOR (vector
)->contents
;
1348 for (i
= 0; i
< size
; i
++)
1350 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1358 /* flag = 1 means check for ] to terminate rather than ) and .
1359 flag = -1 means check for starting with defun
1360 and make structure pure. */
1363 read_list (flag
, readcharfun
)
1365 register Lisp_Object readcharfun
;
1367 /* -1 means check next element for defun,
1368 0 means don't check,
1369 1 means already checked and found defun. */
1370 int defunflag
= flag
< 0 ? -1 : 0;
1371 Lisp_Object val
, tail
;
1372 register Lisp_Object elt
, tem
;
1373 struct gcpro gcpro1
, gcpro2
;
1381 elt
= read1 (readcharfun
);
1383 if (XTYPE (elt
) == Lisp_Internal
)
1387 if (XINT (elt
) == ']')
1389 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1391 if (XINT (elt
) == ')')
1393 if (XINT (elt
) == '.')
1397 XCONS (tail
)->cdr
= read0 (readcharfun
);
1399 val
= read0 (readcharfun
);
1400 elt
= read1 (readcharfun
);
1402 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1404 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1406 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1408 tem
= (read_pure
&& flag
<= 0
1409 ? pure_cons (elt
, Qnil
)
1410 : Fcons (elt
, Qnil
));
1412 XCONS (tail
)->cdr
= tem
;
1417 defunflag
= EQ (elt
, Qdefun
);
1418 else if (defunflag
> 0)
1423 Lisp_Object Vobarray
;
1424 Lisp_Object initial_obarray
;
1427 check_obarray (obarray
)
1428 Lisp_Object obarray
;
1430 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1432 /* If Vobarray is now invalid, force it to be valid. */
1433 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1435 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1440 static int hash_string ();
1441 Lisp_Object
oblookup ();
1448 int len
= strlen (str
);
1449 Lisp_Object obarray
= Vobarray
;
1451 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1452 obarray
= check_obarray (obarray
);
1453 tem
= oblookup (obarray
, str
, len
);
1454 if (XTYPE (tem
) == Lisp_Symbol
)
1456 return Fintern ((!NILP (Vpurify_flag
)
1457 ? make_pure_string (str
, len
)
1458 : make_string (str
, len
)),
1462 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1463 "Return the canonical symbol whose name is STRING.\n\
1464 If there is none, one is created by this function and returned.\n\
1465 A second optional argument specifies the obarray to use;\n\
1466 it defaults to the value of `obarray'.")
1468 Lisp_Object str
, obarray
;
1470 register Lisp_Object tem
, sym
, *ptr
;
1472 if (NILP (obarray
)) obarray
= Vobarray
;
1473 obarray
= check_obarray (obarray
);
1475 CHECK_STRING (str
, 0);
1477 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1478 if (XTYPE (tem
) != Lisp_Int
)
1481 if (!NILP (Vpurify_flag
))
1482 str
= Fpurecopy (str
);
1483 sym
= Fmake_symbol (str
);
1485 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1486 if (XTYPE (*ptr
) == Lisp_Symbol
)
1487 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1489 XSYMBOL (sym
)->next
= 0;
1494 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1495 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1496 A second optional argument specifies the obarray to use;\n\
1497 it defaults to the value of `obarray'.")
1499 Lisp_Object str
, obarray
;
1501 register Lisp_Object tem
;
1503 if (NILP (obarray
)) obarray
= Vobarray
;
1504 obarray
= check_obarray (obarray
);
1506 CHECK_STRING (str
, 0);
1508 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1509 if (XTYPE (tem
) != Lisp_Int
)
1515 oblookup (obarray
, ptr
, size
)
1516 Lisp_Object obarray
;
1521 register Lisp_Object tail
;
1522 Lisp_Object bucket
, tem
;
1524 if (XTYPE (obarray
) != Lisp_Vector
||
1525 (obsize
= XVECTOR (obarray
)->size
) == 0)
1527 obarray
= check_obarray (obarray
);
1528 obsize
= XVECTOR (obarray
)->size
;
1530 /* Combining next two lines breaks VMS C 2.3. */
1531 hash
= hash_string (ptr
, size
);
1533 bucket
= XVECTOR (obarray
)->contents
[hash
];
1534 if (XFASTINT (bucket
) == 0)
1536 else if (XTYPE (bucket
) != Lisp_Symbol
)
1537 error ("Bad data in guts of obarray"); /* Like CADR error message */
1538 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1540 if (XSYMBOL (tail
)->name
->size
== size
&&
1541 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1543 else if (XSYMBOL (tail
)->next
== 0)
1546 XSET (tem
, Lisp_Int
, hash
);
1551 hash_string (ptr
, len
)
1555 register unsigned char *p
= ptr
;
1556 register unsigned char *end
= p
+ len
;
1557 register unsigned char c
;
1558 register int hash
= 0;
1563 if (c
>= 0140) c
-= 40;
1564 hash
= ((hash
<<3) + (hash
>>28) + c
);
1566 return hash
& 07777777777;
1570 map_obarray (obarray
, fn
, arg
)
1571 Lisp_Object obarray
;
1576 register Lisp_Object tail
;
1577 CHECK_VECTOR (obarray
, 1);
1578 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1580 tail
= XVECTOR (obarray
)->contents
[i
];
1581 if (XFASTINT (tail
) != 0)
1585 if (XSYMBOL (tail
)->next
== 0)
1587 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1592 mapatoms_1 (sym
, function
)
1593 Lisp_Object sym
, function
;
1595 call1 (function
, sym
);
1598 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1599 "Call FUNCTION on every symbol in OBARRAY.\n\
1600 OBARRAY defaults to the value of `obarray'.")
1602 Lisp_Object function
, obarray
;
1606 if (NILP (obarray
)) obarray
= Vobarray
;
1607 obarray
= check_obarray (obarray
);
1609 map_obarray (obarray
, mapatoms_1
, function
);
1613 #define OBARRAY_SIZE 1511
1618 Lisp_Object oblength
;
1622 XFASTINT (oblength
) = OBARRAY_SIZE
;
1624 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1625 Vobarray
= Fmake_vector (oblength
, make_number (0));
1626 initial_obarray
= Vobarray
;
1627 staticpro (&initial_obarray
);
1628 /* Intern nil in the obarray */
1629 /* These locals are to kludge around a pyramid compiler bug. */
1630 hash
= hash_string ("nil", 3);
1631 /* Separate statement here to avoid VAXC bug. */
1632 hash
%= OBARRAY_SIZE
;
1633 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1636 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1637 XSYMBOL (Qnil
)->function
= Qunbound
;
1638 XSYMBOL (Qunbound
)->value
= Qunbound
;
1639 XSYMBOL (Qunbound
)->function
= Qunbound
;
1642 XSYMBOL (Qnil
)->value
= Qnil
;
1643 XSYMBOL (Qnil
)->plist
= Qnil
;
1644 XSYMBOL (Qt
)->value
= Qt
;
1646 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1649 Qvariable_documentation
= intern ("variable-documentation");
1651 read_buffer_size
= 100;
1652 read_buffer
= (char *) malloc (read_buffer_size
);
1657 struct Lisp_Subr
*sname
;
1660 sym
= intern (sname
->symbol_name
);
1661 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1664 #ifdef NOTDEF /* use fset in subr.el now */
1666 defalias (sname
, string
)
1667 struct Lisp_Subr
*sname
;
1671 sym
= intern (string
);
1672 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1676 /* New replacement for DefIntVar; it ignores the doc string argument
1677 on the assumption that make-docfile will handle that. */
1678 /* Define an "integer variable"; a symbol whose value is forwarded
1679 to a C variable of type int. Sample call: */
1680 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1683 defvar_int (namestring
, address
, doc
)
1689 sym
= intern (namestring
);
1690 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1693 /* Similar but define a variable whose value is T if address contains 1,
1694 NIL if address contains 0 */
1697 defvar_bool (namestring
, address
, doc
)
1703 sym
= intern (namestring
);
1704 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1707 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1710 defvar_lisp (namestring
, address
, doc
)
1712 Lisp_Object
*address
;
1716 sym
= intern (namestring
);
1717 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1718 staticpro (address
);
1721 /* Similar but don't request gc-marking of the C variable.
1722 Used when that variable will be gc-marked for some other reason,
1723 since marking the same slot twice can cause trouble with strings. */
1726 defvar_lisp_nopro (namestring
, address
, doc
)
1728 Lisp_Object
*address
;
1732 sym
= intern (namestring
);
1733 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1738 /* Similar but define a variable whose value is the Lisp Object stored in
1739 the current buffer. address is the address of the slot in the buffer that is current now. */
1742 defvar_per_buffer (namestring
, address
, type
, doc
)
1744 Lisp_Object
*address
;
1750 extern struct buffer buffer_local_symbols
;
1752 sym
= intern (namestring
);
1753 offset
= (char *)address
- (char *)current_buffer
;
1755 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1756 (Lisp_Object
*) offset
);
1757 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1758 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1759 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1760 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1761 slot of buffer_local_flags */
1765 #endif /* standalone */
1771 /* Compute the default load-path. */
1773 normal
= PATH_LOADSEARCH
;
1774 Vload_path
= decode_env_path (0, normal
);
1776 if (NILP (Vpurify_flag
))
1777 normal
= PATH_LOADSEARCH
;
1779 normal
= PATH_DUMPLOADSEARCH
;
1781 /* In a dumped Emacs, we normally have to reset the value of
1782 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1783 uses ../lisp, instead of the path of the installed elisp
1784 libraries. However, if it appears that Vload_path was changed
1785 from the default before dumping, don't override that value. */
1788 Lisp_Object dump_path
;
1790 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1791 if (! NILP (Fequal (dump_path
, Vload_path
)))
1793 Vload_path
= decode_env_path (0, normal
);
1794 if (!NILP (Vinvocation_directory
))
1796 /* Add to the path the ../lisp dir of the Emacs executable,
1797 if that dir exists. */
1798 Lisp_Object tem
, tem1
;
1799 tem
= Fexpand_file_name (build_string ("../lisp"),
1800 Vinvocation_directory
);
1801 tem1
= Ffile_exists_p (tem
);
1802 if (!NILP (tem1
) && NILP (Fmember (tem
, Vload_path
)))
1803 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1808 Vload_path
= decode_env_path (0, normal
);
1811 /* Warn if dirs in the *standard* path don't exist. */
1813 Lisp_Object path_tail
;
1815 for (path_tail
= Vload_path
;
1817 path_tail
= XCONS (path_tail
)->cdr
)
1819 Lisp_Object dirfile
;
1820 dirfile
= Fcar (path_tail
);
1821 if (XTYPE (dirfile
) == Lisp_String
)
1823 dirfile
= Fdirectory_file_name (dirfile
);
1824 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1825 printf ("Warning: lisp library (%s) does not exist.\n",
1826 XSTRING (Fcar (path_tail
))->data
);
1831 /* If the EMACSLOADPATH environment variable is set, use its value.
1832 This doesn't apply if we're dumping. */
1833 if (NILP (Vpurify_flag
)
1834 && egetenv ("EMACSLOADPATH"))
1835 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1839 load_in_progress
= 0;
1846 defsubr (&Sread_from_string
);
1848 defsubr (&Sintern_soft
);
1850 defsubr (&Seval_buffer
);
1851 defsubr (&Seval_region
);
1852 defsubr (&Sread_char
);
1853 defsubr (&Sread_char_exclusive
);
1854 defsubr (&Sread_event
);
1855 defsubr (&Sget_file_char
);
1856 defsubr (&Smapatoms
);
1858 DEFVAR_LISP ("obarray", &Vobarray
,
1859 "Symbol table for use by `intern' and `read'.\n\
1860 It is a vector whose length ought to be prime for best results.\n\
1861 The vector's contents don't make sense if examined from Lisp programs;\n\
1862 to find all the symbols in an obarray, use `mapatoms'.");
1864 DEFVAR_LISP ("values", &Vvalues
,
1865 "List of values of all expressions which were read, evaluated and printed.\n\
1866 Order is reverse chronological.");
1868 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1869 "Stream for read to get input from.\n\
1870 See documentation of `read' for possible values.");
1871 Vstandard_input
= Qt
;
1873 DEFVAR_LISP ("load-path", &Vload_path
,
1874 "*List of directories to search for files to load.\n\
1875 Each element is a string (directory name) or nil (try default directory).\n\
1876 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1877 otherwise to default specified by file `paths.h' when Emacs was built.");
1879 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1880 "Non-nil iff inside of `load'.");
1882 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1883 "An alist of expressions to be evalled when particular files are loaded.\n\
1884 Each element looks like (FILENAME FORMS...).\n\
1885 When `load' is run and the file-name argument is FILENAME,\n\
1886 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1887 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1888 with no directory specified, since that is how `load' is normally called.\n\
1889 An error in FORMS does not undo the load,\n\
1890 but does prevent execution of the rest of the FORMS.");
1891 Vafter_load_alist
= Qnil
;
1893 DEFVAR_LISP ("load-history", &Vload_history
,
1894 "Alist mapping source file names to symbols and features.\n\
1895 Each alist element is a list that starts with a file name,\n\
1896 except for one element (optional) that starts with nil and describes\n\
1897 definitions evaluated from buffers not visiting files.\n\
1898 The remaining elements of each list are symbols defined as functions\n\
1899 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1900 Vload_history
= Qnil
;
1902 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1903 "Used for internal purposes by `load'.");
1904 Vcurrent_load_list
= Qnil
;
1906 Qcurrent_load_list
= intern ("current-load-list");
1907 staticpro (&Qcurrent_load_list
);
1909 Qstandard_input
= intern ("standard-input");
1910 staticpro (&Qstandard_input
);
1912 Qread_char
= intern ("read-char");
1913 staticpro (&Qread_char
);
1915 Qget_file_char
= intern ("get-file-char");
1916 staticpro (&Qget_file_char
);
1918 Qascii_character
= intern ("ascii-character");
1919 staticpro (&Qascii_character
);
1921 Qload
= intern ("load");