1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989,
3 1993 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include <sys/types.h>
35 #include "termhooks.h"
39 #include <sys/inode.h>
46 #ifdef LISP_FLOAT_TYPE
51 #if 0 /* That is untrue--XINT is used below, and it uses INTBITS.
52 What in the world is values.h, anyway? */
54 /* These are redefined in <values.h> and not used here */
62 #endif /* LISP_FLOAT_TYPE */
64 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
65 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
66 Lisp_Object Qascii_character
, Qload
;
68 extern Lisp_Object Qevent_symbol_element_mask
;
70 /* non-zero if inside `load' */
73 /* Search path for files to be loaded. */
74 Lisp_Object Vload_path
;
76 /* This is the user-visible association list that maps features to
77 lists of defs in their load files. */
78 Lisp_Object Vload_history
;
80 /* This is useud to build the load history. */
81 Lisp_Object Vcurrent_load_list
;
83 /* List of descriptors now open for Fload. */
84 static Lisp_Object load_descriptor_list
;
86 /* File for get_file_char to read from. Use by load */
87 static FILE *instream
;
89 /* When nonzero, read conses in pure space */
92 /* For use within read-from-string (this reader is non-reentrant!!) */
93 static int read_from_string_index
;
94 static int read_from_string_limit
;
96 /* Handle unreading and rereading of characters.
97 Write READCHAR to read a character,
98 UNREAD(c) to unread c to be read again. */
100 #define READCHAR readchar (readcharfun)
101 #define UNREAD(c) unreadchar (readcharfun, c)
104 readchar (readcharfun
)
105 Lisp_Object readcharfun
;
108 register struct buffer
*inbuffer
;
109 register int c
, mpos
;
111 if (XTYPE (readcharfun
) == Lisp_Buffer
)
113 inbuffer
= XBUFFER (readcharfun
);
115 if (BUF_PT (inbuffer
) >= BUF_ZV (inbuffer
))
117 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, BUF_PT (inbuffer
));
118 SET_BUF_PT (inbuffer
, BUF_PT (inbuffer
) + 1);
122 if (XTYPE (readcharfun
) == Lisp_Marker
)
124 inbuffer
= XMARKER (readcharfun
)->buffer
;
126 mpos
= marker_position (readcharfun
);
128 if (mpos
> BUF_ZV (inbuffer
) - 1)
130 c
= *(unsigned char *) BUF_CHAR_ADDRESS (inbuffer
, mpos
);
131 if (mpos
!= BUF_GPT (inbuffer
))
132 XMARKER (readcharfun
)->bufpos
++;
134 Fset_marker (readcharfun
, make_number (mpos
+ 1),
135 Fmarker_buffer (readcharfun
));
138 if (EQ (readcharfun
, Qget_file_char
))
139 return getc (instream
);
141 if (XTYPE (readcharfun
) == Lisp_String
)
144 /* This used to be return of a conditional expression,
145 but that truncated -1 to a char on VMS. */
146 if (read_from_string_index
< read_from_string_limit
)
147 c
= XSTRING (readcharfun
)->data
[read_from_string_index
++];
153 tem
= call0 (readcharfun
);
160 /* Unread the character C in the way appropriate for the stream READCHARFUN.
161 If the stream is a user function, call it with the char as argument. */
164 unreadchar (readcharfun
, c
)
165 Lisp_Object readcharfun
;
168 if (XTYPE (readcharfun
) == Lisp_Buffer
)
170 if (XBUFFER (readcharfun
) == current_buffer
)
173 SET_BUF_PT (XBUFFER (readcharfun
), BUF_PT (XBUFFER (readcharfun
)) - 1);
175 else if (XTYPE (readcharfun
) == Lisp_Marker
)
176 XMARKER (readcharfun
)->bufpos
--;
177 else if (XTYPE (readcharfun
) == Lisp_String
)
178 read_from_string_index
--;
179 else if (EQ (readcharfun
, Qget_file_char
))
180 ungetc (c
, instream
);
182 call1 (readcharfun
, make_number (c
));
185 static Lisp_Object
read0 (), read1 (), read_list (), read_vector ();
187 /* get a character from the tty */
189 extern Lisp_Object
read_char ();
191 /* Read input events until we get one that's acceptable for our purposes.
193 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
194 until we get a character we like, and then stuffed into
197 If ASCII_REQUIRED is non-zero, we check function key events to see
198 if the unmodified version of the symbol has a Qascii_character
199 property, and use that character, if present.
201 If ERROR_NONASCII is non-zero, we signal an error if the input we
202 get isn't an ASCII character with modifiers. If it's zero but
203 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
206 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
)
207 int no_switch_frame
, ascii_required
, error_nonascii
;
210 return make_number (getchar ());
212 register Lisp_Object val
;
213 register Lisp_Object delayed_switch_frame
= Qnil
;
215 /* Read until we get an acceptable event. */
217 val
= read_char (0, 0, 0, Qnil
, 0);
219 /* switch-frame events are put off until after the next ASCII
220 character. This is better than signalling an error just because
221 the last characters were typed to a separate minibuffer frame,
222 for example. Eventually, some code which can deal with
223 switch-frame events will read it and process it. */
225 && EVENT_HAS_PARAMETERS (val
)
226 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
228 delayed_switch_frame
= val
;
234 /* Convert certain symbols to their ASCII equivalents. */
235 if (XTYPE (val
) == Lisp_Symbol
)
237 Lisp_Object tem
, tem1
, tem2
;
238 tem
= Fget (val
, Qevent_symbol_element_mask
);
241 tem1
= Fget (Fcar (tem
), Qascii_character
);
242 /* Merge this symbol's modifier bits
243 with the ASCII equivalent of its basic code. */
245 XFASTINT (val
) = XINT (tem1
) | XINT (Fcar (Fcdr (tem
)));
249 /* If we don't have a character now, deal with it appropriately. */
250 if (XTYPE (val
) != Lisp_Int
)
254 unread_command_events
= Fcons (val
, Qnil
);
255 error ("Non-character input-event");
262 if (! NILP (delayed_switch_frame
))
263 unread_switch_frame
= delayed_switch_frame
;
269 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 0, 0,
270 "Read a character from the command input (keyboard or macro).\n\
271 It is returned as a number.\n\
272 If the user generates an event which is not a character (i.e. a mouse\n\
273 click or function key event), `read-char' signals an error. As an\n\
274 exception, switch-frame events are put off until non-ASCII events can\n\
276 If you want to read non-character events, or ignore them, call\n\
277 `read-event' or `read-char-exclusive' instead.")
280 return read_filtered_event (1, 1, 1);
283 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 0, 0,
284 "Read an event object from the input stream.")
287 return read_filtered_event (0, 0, 0);
290 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 0, 0,
291 "Read a character from the command input (keyboard or macro).\n\
292 It is returned as a number. Non character events are ignored.")
295 return read_filtered_event (1, 1, 0);
298 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
299 "Don't use this yourself.")
302 register Lisp_Object val
;
303 XSET (val
, Lisp_Int
, getc (instream
));
307 static void readevalloop ();
308 static Lisp_Object
load_unwind ();
309 static Lisp_Object
load_descriptor_unwind ();
311 DEFUN ("load", Fload
, Sload
, 1, 4, 0,
312 "Execute a file of Lisp code named FILE.\n\
313 First try FILE with `.elc' appended, then try with `.el',\n\
314 then try FILE unmodified.\n\
315 This function searches the directories in `load-path'.\n\
316 If optional second arg NOERROR is non-nil,\n\
317 report no error if FILE doesn't exist.\n\
318 Print messages at start and end of loading unless\n\
319 optional third arg NOMESSAGE is non-nil.\n\
320 If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
321 suffixes `.elc' or `.el' to the specified name FILE.\n\
322 Return t if file exists.")
323 (str
, noerror
, nomessage
, nosuffix
)
324 Lisp_Object str
, noerror
, nomessage
, nosuffix
;
326 register FILE *stream
;
327 register int fd
= -1;
328 register Lisp_Object lispstream
;
330 int count
= specpdl_ptr
- specpdl
;
334 /* 1 means inhibit the message at the beginning. */
338 char *dosmode
= "rt";
341 CHECK_STRING (str
, 0);
342 str
= Fsubstitute_in_file_name (str
);
344 /* If file name is magic, call the handler. */
345 handler
= Ffind_file_name_handler (str
);
347 return call5 (handler
, Qload
, str
, noerror
, nomessage
, nosuffix
);
349 /* Avoid weird lossage with null string as arg,
350 since it would try to load a directory as a Lisp file */
351 if (XSTRING (str
)->size
> 0)
353 fd
= openp (Vload_path
, str
, !NILP (nosuffix
) ? "" : ".elc:.el:",
361 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
367 if (!bcmp (&(XSTRING (found
)->data
[XSTRING (found
)->size
- 4]),
376 stat (XSTRING (found
)->data
, &s1
);
377 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 0;
378 result
= stat (XSTRING (found
)->data
, &s2
);
379 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
381 message ("Source file `%s' newer than byte-compiled file",
382 XSTRING (found
)->data
);
383 /* Don't immediately overwrite this message. */
387 XSTRING (found
)->data
[XSTRING (found
)->size
- 1] = 'c';
392 stream
= fopen ((char *) XSTRING (found
)->data
, dosmode
);
394 stream
= fdopen (fd
, "r");
399 error ("Failure to create stdio stream for %s", XSTRING (str
)->data
);
402 if (NILP (nomessage
) && !nomessage1
)
403 message ("Loading %s...", XSTRING (str
)->data
);
406 /* We may not be able to store STREAM itself as a Lisp_Object pointer
407 since that is guaranteed to work only for data that has been malloc'd.
408 So malloc a full-size pointer, and record the address of that pointer. */
409 ptr
= (FILE **) xmalloc (sizeof (FILE *));
411 XSET (lispstream
, Lisp_Internal_Stream
, (int) ptr
);
412 record_unwind_protect (load_unwind
, lispstream
);
413 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
415 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
417 readevalloop (Qget_file_char
, stream
, str
, Feval
, 0);
418 unbind_to (count
, Qnil
);
420 /* Run any load-hooks for this file. */
421 temp
= Fassoc (str
, Vafter_load_alist
);
423 Fprogn (Fcdr (temp
));
426 if (!noninteractive
&& NILP (nomessage
))
427 message ("Loading %s...done", XSTRING (str
)->data
);
432 load_unwind (stream
) /* used as unwind-protect function in load */
435 fclose (*(FILE **) XSTRING (stream
));
436 xfree (XPNTR (stream
));
437 if (--load_in_progress
< 0) load_in_progress
= 0;
442 load_descriptor_unwind (oldlist
)
445 load_descriptor_list
= oldlist
;
448 /* Close all descriptors in use for Floads.
449 This is used when starting a subprocess. */
455 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCONS (tail
)->cdr
)
456 close (XFASTINT (XCONS (tail
)->car
));
460 complete_filename_p (pathname
)
461 Lisp_Object pathname
;
463 register unsigned char *s
= XSTRING (pathname
)->data
;
471 #ifdef MSDOS /* MW, May 1993 */
472 || (s
[0] != '\0' && s
[1] == ':' && s
[2] == '/')
477 /* Search for a file whose name is STR, looking in directories
478 in the Lisp list PATH, and trying suffixes from SUFFIX.
479 SUFFIX is a string containing possible suffixes separated by colons.
480 On success, returns a file descriptor. On failure, returns -1.
482 EXEC_ONLY nonzero means don't open the files,
483 just look for one that is executable. In this case,
484 returns 1 on success.
486 If STOREPTR is nonzero, it points to a slot where the name of
487 the file actually found should be stored as a Lisp string.
488 Nil is stored there on failure. */
491 openp (path
, str
, suffix
, storeptr
, exec_only
)
492 Lisp_Object path
, str
;
494 Lisp_Object
*storeptr
;
500 register char *fn
= buf
;
503 register Lisp_Object filename
;
509 if (complete_filename_p (str
))
512 for (; !NILP (path
); path
= Fcdr (path
))
516 filename
= Fexpand_file_name (str
, Fcar (path
));
517 if (!complete_filename_p (filename
))
518 /* If there are non-absolute elts in PATH (eg ".") */
519 /* Of course, this could conceivably lose if luser sets
520 default-directory to be something non-absolute... */
522 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
523 if (!complete_filename_p (filename
))
524 /* Give up on this path element! */
528 /* Calculate maximum size of any filename made from
529 this path element/specified file name and any possible suffix. */
530 want_size
= strlen (suffix
) + XSTRING (filename
)->size
+ 1;
531 if (fn_size
< want_size
)
532 fn
= (char *) alloca (fn_size
= 100 + want_size
);
536 /* Loop over suffixes. */
539 char *esuffix
= (char *) index (nsuffix
, ':');
540 int lsuffix
= esuffix
? esuffix
- nsuffix
: strlen (nsuffix
);
542 /* Concatenate path element/specified name with the suffix. */
543 strncpy (fn
, XSTRING (filename
)->data
, XSTRING (filename
)->size
);
544 fn
[XSTRING (filename
)->size
] = 0;
545 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
546 strncat (fn
, nsuffix
, lsuffix
);
548 /* Ignore file if it's a directory. */
549 if (stat (fn
, &st
) >= 0
550 && (st
.st_mode
& S_IFMT
) != S_IFDIR
)
552 /* Check that we can access or open it. */
554 fd
= (access (fn
, X_OK
) == 0) ? 1 : -1;
556 fd
= open (fn
, 0, 0);
560 /* We succeeded; return this descriptor and filename. */
562 *storeptr
= build_string (fn
);
567 /* Advance to next suffix. */
570 nsuffix
+= lsuffix
+ 1;
572 if (absolute
) return -1;
579 /* Merge the list we've accumulated of globals from the current input source
580 into the load_history variable. The details depend on whether
581 the source has an associated file name or not. */
584 build_load_history (stream
, source
)
588 register Lisp_Object tail
, prev
, newelt
;
589 register Lisp_Object tem
, tem2
;
590 register int foundit
, loading
;
592 /* Don't bother recording anything for preloaded files. */
593 if (!NILP (Vpurify_flag
))
596 loading
= stream
|| !NARROWED
;
598 tail
= Vload_history
;
605 /* Find the feature's previous assoc list... */
606 if (!NILP (Fequal (source
, Fcar (tem
))))
610 /* If we're loading, remove it. */
614 Vload_history
= Fcdr (tail
);
616 Fsetcdr (prev
, Fcdr (tail
));
619 /* Otherwise, cons on new symbols that are not already members. */
622 tem2
= Vcurrent_load_list
;
626 newelt
= Fcar (tem2
);
628 if (NILP (Fmemq (newelt
, tem
)))
629 Fsetcar (tail
, Fcons (Fcar (tem
),
630 Fcons (newelt
, Fcdr (tem
))));
643 /* If we're loading, cons the new assoc onto the front of load-history,
644 the most-recently-loaded position. Also do this if we didn't find
645 an existing member for the current source. */
646 if (loading
|| !foundit
)
647 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
652 unreadpure () /* Used as unwind-protect function in readevalloop */
659 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
)
660 Lisp_Object readcharfun
;
662 Lisp_Object sourcename
;
663 Lisp_Object (*evalfun
) ();
667 register Lisp_Object val
;
668 int count
= specpdl_ptr
- specpdl
;
670 struct buffer
*b
= 0;
672 if (BUFFERP (readcharfun
))
673 b
= XBUFFER (readcharfun
);
674 else if (MARKERP (readcharfun
))
675 b
= XMARKER (readcharfun
)->buffer
;
677 specbind (Qstandard_input
, readcharfun
);
678 specbind (Qcurrent_load_list
, Qnil
);
682 LOADHIST_ATTACH (sourcename
);
686 if (b
!= 0 && NILP (b
->name
))
687 error ("Reading from killed buffer");
693 while ((c
= READCHAR
) != '\n' && c
!= -1);
697 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f') continue;
699 if (!NILP (Vpurify_flag
) && c
== '(')
701 record_unwind_protect (unreadpure
, Qnil
);
702 val
= read_list (-1, readcharfun
);
703 unbind_to (count
+ 1, Qnil
);
708 val
= read0 (readcharfun
);
711 val
= (*evalfun
) (val
);
714 Vvalues
= Fcons (val
, Vvalues
);
715 if (EQ (Vstandard_output
, Qt
))
722 build_load_history (stream
, sourcename
);
725 unbind_to (count
, Qnil
);
730 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 2, "",
731 "Execute the current buffer as Lisp code.\n\
732 Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
733 BUFFER is the buffer to evaluate (nil means use current buffer).\n\
734 PRINTFLAG controls printing of output:\n\
735 nil means discard it; anything else is stream for print.\n\
737 If there is no error, point does not move. If there is an error,\n\
738 point remains at the end of the last character read from the buffer.")
740 Lisp_Object bufname
, printflag
;
742 int count
= specpdl_ptr
- specpdl
;
743 Lisp_Object tem
, buf
;
746 buf
= Fcurrent_buffer ();
748 buf
= Fget_buffer (bufname
);
750 error ("No such buffer.");
752 if (NILP (printflag
))
756 specbind (Qstandard_output
, tem
);
757 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
758 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
759 readevalloop (buf
, 0, XBUFFER (buf
)->filename
, Feval
, !NILP (printflag
));
760 unbind_to (count
, Qnil
);
766 DEFUN ("eval-current-buffer", Feval_current_buffer
, Seval_current_buffer
, 0, 1, "",
767 "Execute the current buffer as Lisp code.\n\
768 Programs can pass argument PRINTFLAG which controls printing of output:\n\
769 nil means discard it; anything else is stream for print.\n\
771 If there is no error, point does not move. If there is an error,\n\
772 point remains at the end of the last character read from the buffer.")
774 Lisp_Object printflag
;
776 int count
= specpdl_ptr
- specpdl
;
777 Lisp_Object tem
, cbuf
;
779 cbuf
= Fcurrent_buffer ()
781 if (NILP (printflag
))
785 specbind (Qstandard_output
, tem
);
786 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
788 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
789 return unbind_to (count
, Qnil
);
793 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 3, "r",
794 "Execute the region as Lisp code.\n\
795 When called from programs, expects two arguments,\n\
796 giving starting and ending indices in the current buffer\n\
797 of the text to be executed.\n\
798 Programs can pass third argument PRINTFLAG which controls output:\n\
799 nil means discard it; anything else is stream for printing it.\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 b
, e
, 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
);
817 if (NILP (printflag
))
818 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
819 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
821 /* This both uses b and checks its type. */
823 Fnarrow_to_region (make_number (BEGV
), e
);
824 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
, !NILP (printflag
));
826 return unbind_to (count
, Qnil
);
829 #endif /* standalone */
831 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
832 "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
833 If STREAM is nil, use the value of `standard-input' (which see).\n\
834 STREAM or the value of `standard-input' may be:\n\
835 a buffer (read from point and advance it)\n\
836 a marker (read from where it points and advance it)\n\
837 a function (call it with no arguments for each character,\n\
838 call it with a char as argument to push a char back)\n\
839 a string (takes text from string, starting at the beginning)\n\
840 t (read text line using minibuffer and use it).")
842 Lisp_Object readcharfun
;
844 extern Lisp_Object
Fread_minibuffer ();
846 if (NILP (readcharfun
))
847 readcharfun
= Vstandard_input
;
848 if (EQ (readcharfun
, Qt
))
849 readcharfun
= Qread_char
;
852 if (EQ (readcharfun
, Qread_char
))
853 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
856 if (XTYPE (readcharfun
) == Lisp_String
)
857 return Fcar (Fread_from_string (readcharfun
, Qnil
, Qnil
));
859 return read0 (readcharfun
);
862 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
863 "Read one Lisp expression which is represented as text by STRING.\n\
864 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
865 START and END optionally delimit a substring of STRING from which to read;\n\
866 they default to 0 and (length STRING) respectively.")
868 Lisp_Object string
, start
, end
;
870 int startval
, endval
;
873 CHECK_STRING (string
,0);
876 endval
= XSTRING (string
)->size
;
878 { CHECK_NUMBER (end
,2);
880 if (endval
< 0 || endval
> XSTRING (string
)->size
)
881 args_out_of_range (string
, end
);
887 { CHECK_NUMBER (start
,1);
888 startval
= XINT (start
);
889 if (startval
< 0 || startval
> endval
)
890 args_out_of_range (string
, start
);
893 read_from_string_index
= startval
;
894 read_from_string_limit
= endval
;
896 tem
= read0 (string
);
897 return Fcons (tem
, make_number (read_from_string_index
));
900 /* Use this for recursive reads, in contexts where internal tokens are not allowed. */
904 Lisp_Object readcharfun
;
906 register Lisp_Object val
;
909 val
= read1 (readcharfun
);
910 if (XTYPE (val
) == Lisp_Internal
)
913 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (&c
, 1), Qnil
));
919 static int read_buffer_size
;
920 static char *read_buffer
;
923 read_escape (readcharfun
)
924 Lisp_Object readcharfun
;
926 register int c
= READCHAR
;
953 error ("Invalid escape character syntax");
956 c
= read_escape (readcharfun
);
957 return c
| meta_modifier
;
962 error ("Invalid escape character syntax");
965 c
= read_escape (readcharfun
);
966 return c
| shift_modifier
;
971 error ("Invalid escape character syntax");
974 c
= read_escape (readcharfun
);
975 return c
| hyper_modifier
;
980 error ("Invalid escape character syntax");
983 c
= read_escape (readcharfun
);
984 return c
| alt_modifier
;
989 error ("Invalid escape character syntax");
992 c
= read_escape (readcharfun
);
993 return c
| super_modifier
;
998 error ("Invalid escape character syntax");
1002 c
= read_escape (readcharfun
);
1003 if ((c
& 0177) == '?')
1005 /* ASCII control chars are made from letters (both cases),
1006 as well as the non-letters within 0100...0137. */
1007 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1008 return (c
& (037 | ~0177));
1009 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1010 return (c
& (037 | ~0177));
1012 return c
| ctrl_modifier
;
1022 /* An octal escape, as in ANSI C. */
1024 register int i
= c
- '0';
1025 register int count
= 0;
1028 if ((c
= READCHAR
) >= '0' && c
<= '7')
1043 /* A hex escape, as in ANSI C. */
1049 if (c
>= '0' && c
<= '9')
1054 else if ((c
>= 'a' && c
<= 'f')
1055 || (c
>= 'A' && c
<= 'F'))
1058 if (c
>= 'a' && c
<= 'f')
1079 register Lisp_Object readcharfun
;
1086 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1091 return read_list (0, readcharfun
);
1094 return read_vector (readcharfun
);
1099 register Lisp_Object val
;
1100 XSET (val
, Lisp_Internal
, c
);
1108 /* Accept compiled functions at read-time so that we don't have to
1109 build them using function calls. */
1111 tmp
= read_vector (readcharfun
);
1112 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1113 XVECTOR (tmp
)->contents
);
1115 #ifdef USE_TEXT_PROPERTIES
1119 struct gcpro gcpro1
;
1121 /* Read the string itself. */
1122 tmp
= read1 (readcharfun
);
1123 if (XTYPE (tmp
) != Lisp_String
)
1124 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1126 /* Read the intervals and their properties. */
1129 Lisp_Object beg
, end
, plist
;
1131 beg
= read1 (readcharfun
);
1132 if (XTYPE (beg
) == Lisp_Internal
)
1134 if (XINT (beg
) == ')')
1136 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("invalid string property list", 28), Qnil
));
1138 end
= read1 (readcharfun
);
1139 if (XTYPE (end
) == Lisp_Internal
)
1140 Fsignal (Qinvalid_read_syntax
,
1141 Fcons (make_string ("invalid string property list", 28), Qnil
));
1143 plist
= read1 (readcharfun
);
1144 if (XTYPE (plist
) == Lisp_Internal
)
1145 Fsignal (Qinvalid_read_syntax
,
1146 Fcons (make_string ("invalid string property list", 28), Qnil
));
1147 Fset_text_properties (beg
, end
, plist
, tmp
);
1154 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
1157 while ((c
= READCHAR
) >= 0 && c
!= '\n');
1162 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
1167 register Lisp_Object val
;
1170 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1173 XSET (val
, Lisp_Int
, read_escape (readcharfun
));
1175 XSET (val
, Lisp_Int
, c
);
1182 register char *p
= read_buffer
;
1183 register char *end
= read_buffer
+ read_buffer_size
;
1187 while ((c
= READCHAR
) >= 0
1192 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1193 p
+= new - read_buffer
;
1194 read_buffer
+= new - read_buffer
;
1195 end
= read_buffer
+ read_buffer_size
;
1198 c
= read_escape (readcharfun
);
1199 /* c is -1 if \ newline has just been seen */
1202 if (p
== read_buffer
)
1205 else if (c
& CHAR_META
)
1206 /* Move the meta bit to the right place for a string. */
1207 *p
++ = (c
& ~CHAR_META
) | 0x80;
1211 if (c
< 0) return Fsignal (Qend_of_file
, Qnil
);
1213 /* If purifying, and string starts with \ newline,
1214 return zero instead. This is for doc strings
1215 that we are really going to find in etc/DOC.nn.nn */
1216 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
1217 return make_number (0);
1220 return make_pure_string (read_buffer
, p
- read_buffer
);
1222 return make_string (read_buffer
, p
- read_buffer
);
1227 #ifdef LISP_FLOAT_TYPE
1228 /* If a period is followed by a number, then we should read it
1229 as a floating point number. Otherwise, it denotes a dotted
1231 int next_char
= READCHAR
;
1234 if (! isdigit (next_char
))
1237 register Lisp_Object val
;
1238 XSET (val
, Lisp_Internal
, c
);
1242 /* Otherwise, we fall through! Note that the atom-reading loop
1243 below will now loop at least once, assuring that we will not
1244 try to UNREAD two characters in a row. */
1247 if (c
<= 040) goto retry
;
1249 register char *p
= read_buffer
;
1253 register char *end
= read_buffer
+ read_buffer_size
;
1256 !(c
== '\"' || c
== '\'' || c
== ';' || c
== '?'
1257 || c
== '(' || c
== ')'
1258 #ifndef LISP_FLOAT_TYPE
1259 /* If we have floating-point support, then we need
1260 to allow <digits><dot><digits>. */
1262 #endif /* not LISP_FLOAT_TYPE */
1263 || c
== '[' || c
== ']' || c
== '#'
1268 register char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1269 p
+= new - read_buffer
;
1270 read_buffer
+= new - read_buffer
;
1271 end
= read_buffer
+ read_buffer_size
;
1284 char *new = (char *) xrealloc (read_buffer
, read_buffer_size
*= 2);
1285 p
+= new - read_buffer
;
1286 read_buffer
+= new - read_buffer
;
1287 /* end = read_buffer + read_buffer_size; */
1297 register Lisp_Object val
;
1299 if (*p1
== '+' || *p1
== '-') p1
++;
1300 /* Is it an integer? */
1303 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
1304 #ifdef LISP_FLOAT_TYPE
1305 /* Integers can have trailing decimal points. */
1306 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
1309 /* It is an integer. */
1311 #ifdef LISP_FLOAT_TYPE
1315 XSET (val
, Lisp_Int
, atoi (read_buffer
));
1319 #ifdef LISP_FLOAT_TYPE
1320 if (isfloat_string (read_buffer
))
1321 return make_float (atof (read_buffer
));
1325 return intern (read_buffer
);
1330 #ifdef LISP_FLOAT_TYPE
1345 if (*cp
== '+' || *cp
== '-')
1351 while (isdigit (*cp
))
1362 while (isdigit (*cp
))
1370 if ((*cp
== '+') || (*cp
== '-'))
1376 while (isdigit (*cp
))
1380 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
1381 || state
== (DOT_CHAR
|TRAIL_INT
)
1382 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
1383 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
1384 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
1386 #endif /* LISP_FLOAT_TYPE */
1389 read_vector (readcharfun
)
1390 Lisp_Object readcharfun
;
1394 register Lisp_Object
*ptr
;
1395 register Lisp_Object tem
, vector
;
1396 register struct Lisp_Cons
*otem
;
1399 tem
= read_list (1, readcharfun
);
1400 len
= Flength (tem
);
1401 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
1404 size
= XVECTOR (vector
)->size
;
1405 ptr
= XVECTOR (vector
)->contents
;
1406 for (i
= 0; i
< size
; i
++)
1408 ptr
[i
] = read_pure
? Fpurecopy (Fcar (tem
)) : Fcar (tem
);
1416 /* flag = 1 means check for ] to terminate rather than ) and .
1417 flag = -1 means check for starting with defun
1418 and make structure pure. */
1421 read_list (flag
, readcharfun
)
1423 register Lisp_Object readcharfun
;
1425 /* -1 means check next element for defun,
1426 0 means don't check,
1427 1 means already checked and found defun. */
1428 int defunflag
= flag
< 0 ? -1 : 0;
1429 Lisp_Object val
, tail
;
1430 register Lisp_Object elt
, tem
;
1431 struct gcpro gcpro1
, gcpro2
;
1439 elt
= read1 (readcharfun
);
1441 if (XTYPE (elt
) == Lisp_Internal
)
1445 if (XINT (elt
) == ']')
1447 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (") or . in a vector", 18), Qnil
));
1449 if (XINT (elt
) == ')')
1451 if (XINT (elt
) == '.')
1455 XCONS (tail
)->cdr
= read0 (readcharfun
);
1457 val
= read0 (readcharfun
);
1458 elt
= read1 (readcharfun
);
1460 if (XTYPE (elt
) == Lisp_Internal
&& XINT (elt
) == ')')
1462 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
1464 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
1466 tem
= (read_pure
&& flag
<= 0
1467 ? pure_cons (elt
, Qnil
)
1468 : Fcons (elt
, Qnil
));
1470 XCONS (tail
)->cdr
= tem
;
1475 defunflag
= EQ (elt
, Qdefun
);
1476 else if (defunflag
> 0)
1481 Lisp_Object Vobarray
;
1482 Lisp_Object initial_obarray
;
1485 check_obarray (obarray
)
1486 Lisp_Object obarray
;
1488 while (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1490 /* If Vobarray is now invalid, force it to be valid. */
1491 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
1493 obarray
= wrong_type_argument (Qvectorp
, obarray
);
1498 static int hash_string ();
1499 Lisp_Object
oblookup ();
1506 int len
= strlen (str
);
1507 Lisp_Object obarray
= Vobarray
;
1509 if (XTYPE (obarray
) != Lisp_Vector
|| XVECTOR (obarray
)->size
== 0)
1510 obarray
= check_obarray (obarray
);
1511 tem
= oblookup (obarray
, str
, len
);
1512 if (XTYPE (tem
) == Lisp_Symbol
)
1514 return Fintern ((!NILP (Vpurify_flag
)
1515 ? make_pure_string (str
, len
)
1516 : make_string (str
, len
)),
1520 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
1521 "Return the canonical symbol whose name is STRING.\n\
1522 If there is none, one is created by this function and returned.\n\
1523 A second optional argument specifies the obarray to use;\n\
1524 it defaults to the value of `obarray'.")
1526 Lisp_Object str
, obarray
;
1528 register Lisp_Object tem
, sym
, *ptr
;
1530 if (NILP (obarray
)) obarray
= Vobarray
;
1531 obarray
= check_obarray (obarray
);
1533 CHECK_STRING (str
, 0);
1535 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1536 if (XTYPE (tem
) != Lisp_Int
)
1539 if (!NILP (Vpurify_flag
))
1540 str
= Fpurecopy (str
);
1541 sym
= Fmake_symbol (str
);
1543 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
1544 if (XTYPE (*ptr
) == Lisp_Symbol
)
1545 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
1547 XSYMBOL (sym
)->next
= 0;
1552 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
1553 "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
1554 A second optional argument specifies the obarray to use;\n\
1555 it defaults to the value of `obarray'.")
1557 Lisp_Object str
, obarray
;
1559 register Lisp_Object tem
;
1561 if (NILP (obarray
)) obarray
= Vobarray
;
1562 obarray
= check_obarray (obarray
);
1564 CHECK_STRING (str
, 0);
1566 tem
= oblookup (obarray
, XSTRING (str
)->data
, XSTRING (str
)->size
);
1567 if (XTYPE (tem
) != Lisp_Int
)
1573 oblookup (obarray
, ptr
, size
)
1574 Lisp_Object obarray
;
1579 register Lisp_Object tail
;
1580 Lisp_Object bucket
, tem
;
1582 if (XTYPE (obarray
) != Lisp_Vector
1583 || (obsize
= XVECTOR (obarray
)->size
) == 0)
1585 obarray
= check_obarray (obarray
);
1586 obsize
= XVECTOR (obarray
)->size
;
1588 /* Combining next two lines breaks VMS C 2.3. */
1589 hash
= hash_string (ptr
, size
);
1591 bucket
= XVECTOR (obarray
)->contents
[hash
];
1592 if (XFASTINT (bucket
) == 0)
1594 else if (XTYPE (bucket
) != Lisp_Symbol
)
1595 error ("Bad data in guts of obarray"); /* Like CADR error message */
1596 else for (tail
= bucket
; ; XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
))
1598 if (XSYMBOL (tail
)->name
->size
== size
&&
1599 !bcmp (XSYMBOL (tail
)->name
->data
, ptr
, size
))
1601 else if (XSYMBOL (tail
)->next
== 0)
1604 XSET (tem
, Lisp_Int
, hash
);
1609 hash_string (ptr
, len
)
1613 register unsigned char *p
= ptr
;
1614 register unsigned char *end
= p
+ len
;
1615 register unsigned char c
;
1616 register int hash
= 0;
1621 if (c
>= 0140) c
-= 40;
1622 hash
= ((hash
<<3) + (hash
>>28) + c
);
1624 return hash
& 07777777777;
1628 map_obarray (obarray
, fn
, arg
)
1629 Lisp_Object obarray
;
1634 register Lisp_Object tail
;
1635 CHECK_VECTOR (obarray
, 1);
1636 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
1638 tail
= XVECTOR (obarray
)->contents
[i
];
1639 if (XFASTINT (tail
) != 0)
1643 if (XSYMBOL (tail
)->next
== 0)
1645 XSET (tail
, Lisp_Symbol
, XSYMBOL (tail
)->next
);
1650 mapatoms_1 (sym
, function
)
1651 Lisp_Object sym
, function
;
1653 call1 (function
, sym
);
1656 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
1657 "Call FUNCTION on every symbol in OBARRAY.\n\
1658 OBARRAY defaults to the value of `obarray'.")
1660 Lisp_Object function
, obarray
;
1664 if (NILP (obarray
)) obarray
= Vobarray
;
1665 obarray
= check_obarray (obarray
);
1667 map_obarray (obarray
, mapatoms_1
, function
);
1671 #define OBARRAY_SIZE 1511
1676 Lisp_Object oblength
;
1680 XFASTINT (oblength
) = OBARRAY_SIZE
;
1682 Qnil
= Fmake_symbol (make_pure_string ("nil", 3));
1683 Vobarray
= Fmake_vector (oblength
, make_number (0));
1684 initial_obarray
= Vobarray
;
1685 staticpro (&initial_obarray
);
1686 /* Intern nil in the obarray */
1687 /* These locals are to kludge around a pyramid compiler bug. */
1688 hash
= hash_string ("nil", 3);
1689 /* Separate statement here to avoid VAXC bug. */
1690 hash
%= OBARRAY_SIZE
;
1691 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
1694 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7));
1695 XSYMBOL (Qnil
)->function
= Qunbound
;
1696 XSYMBOL (Qunbound
)->value
= Qunbound
;
1697 XSYMBOL (Qunbound
)->function
= Qunbound
;
1700 XSYMBOL (Qnil
)->value
= Qnil
;
1701 XSYMBOL (Qnil
)->plist
= Qnil
;
1702 XSYMBOL (Qt
)->value
= Qt
;
1704 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
1707 Qvariable_documentation
= intern ("variable-documentation");
1709 read_buffer_size
= 100;
1710 read_buffer
= (char *) malloc (read_buffer_size
);
1715 struct Lisp_Subr
*sname
;
1718 sym
= intern (sname
->symbol_name
);
1719 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1722 #ifdef NOTDEF /* use fset in subr.el now */
1724 defalias (sname
, string
)
1725 struct Lisp_Subr
*sname
;
1729 sym
= intern (string
);
1730 XSET (XSYMBOL (sym
)->function
, Lisp_Subr
, sname
);
1734 /* New replacement for DefIntVar; it ignores the doc string argument
1735 on the assumption that make-docfile will handle that. */
1736 /* Define an "integer variable"; a symbol whose value is forwarded
1737 to a C variable of type int. Sample call: */
1738 /* DEFVARINT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
1741 defvar_int (namestring
, address
, doc
)
1747 sym
= intern (namestring
);
1748 XSET (XSYMBOL (sym
)->value
, Lisp_Intfwd
, address
);
1751 /* Similar but define a variable whose value is T if address contains 1,
1752 NIL if address contains 0 */
1755 defvar_bool (namestring
, address
, doc
)
1761 sym
= intern (namestring
);
1762 XSET (XSYMBOL (sym
)->value
, Lisp_Boolfwd
, address
);
1765 /* Similar but define a variable whose value is the Lisp Object stored at address. */
1768 defvar_lisp (namestring
, address
, doc
)
1770 Lisp_Object
*address
;
1774 sym
= intern (namestring
);
1775 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1776 staticpro (address
);
1779 /* Similar but don't request gc-marking of the C variable.
1780 Used when that variable will be gc-marked for some other reason,
1781 since marking the same slot twice can cause trouble with strings. */
1784 defvar_lisp_nopro (namestring
, address
, doc
)
1786 Lisp_Object
*address
;
1790 sym
= intern (namestring
);
1791 XSET (XSYMBOL (sym
)->value
, Lisp_Objfwd
, address
);
1796 /* Similar but define a variable whose value is the Lisp Object stored in
1797 the current buffer. address is the address of the slot in the buffer that is current now. */
1800 defvar_per_buffer (namestring
, address
, type
, doc
)
1802 Lisp_Object
*address
;
1808 extern struct buffer buffer_local_symbols
;
1810 sym
= intern (namestring
);
1811 offset
= (char *)address
- (char *)current_buffer
;
1813 XSET (XSYMBOL (sym
)->value
, Lisp_Buffer_Objfwd
,
1814 (Lisp_Object
*) offset
);
1815 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_symbols
) = sym
;
1816 *(Lisp_Object
*)(offset
+ (char *)&buffer_local_types
) = type
;
1817 if (*(int *)(offset
+ (char *)&buffer_local_flags
) == 0)
1818 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
1819 slot of buffer_local_flags */
1823 #endif /* standalone */
1829 /* Compute the default load-path. */
1831 normal
= PATH_LOADSEARCH
;
1832 Vload_path
= decode_env_path (0, normal
);
1834 if (NILP (Vpurify_flag
))
1835 normal
= PATH_LOADSEARCH
;
1837 normal
= PATH_DUMPLOADSEARCH
;
1839 /* In a dumped Emacs, we normally have to reset the value of
1840 Vload_path from PATH_LOADSEARCH, since the value that was dumped
1841 uses ../lisp, instead of the path of the installed elisp
1842 libraries. However, if it appears that Vload_path was changed
1843 from the default before dumping, don't override that value. */
1846 Lisp_Object dump_path
;
1848 dump_path
= decode_env_path (0, PATH_DUMPLOADSEARCH
);
1849 if (! NILP (Fequal (dump_path
, Vload_path
)))
1851 Vload_path
= decode_env_path (0, normal
);
1852 if (!NILP (Vinstallation_directory
))
1854 /* Add to the path the lisp subdir of the
1855 installation dir. */
1857 tem
= Fexpand_file_name (build_string ("lisp"),
1858 Vinstallation_directory
);
1859 if (NILP (Fmember (tem
, Vload_path
)))
1860 Vload_path
= nconc2 (Vload_path
, Fcons (tem
, Qnil
));
1865 Vload_path
= decode_env_path (0, normal
);
1868 /* Warn if dirs in the *standard* path don't exist. */
1870 Lisp_Object path_tail
;
1872 for (path_tail
= Vload_path
;
1874 path_tail
= XCONS (path_tail
)->cdr
)
1876 Lisp_Object dirfile
;
1877 dirfile
= Fcar (path_tail
);
1878 if (XTYPE (dirfile
) == Lisp_String
)
1880 dirfile
= Fdirectory_file_name (dirfile
);
1881 if (access (XSTRING (dirfile
)->data
, 0) < 0)
1882 fprintf (stderr
, "Warning: lisp library (%s) does not exist.\n",
1883 XSTRING (Fcar (path_tail
))->data
);
1888 /* If the EMACSLOADPATH environment variable is set, use its value.
1889 This doesn't apply if we're dumping. */
1890 if (NILP (Vpurify_flag
)
1891 && egetenv ("EMACSLOADPATH"))
1892 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
1896 load_in_progress
= 0;
1898 load_descriptor_list
= Qnil
;
1905 defsubr (&Sread_from_string
);
1907 defsubr (&Sintern_soft
);
1909 defsubr (&Seval_buffer
);
1910 defsubr (&Seval_region
);
1911 defsubr (&Sread_char
);
1912 defsubr (&Sread_char_exclusive
);
1913 defsubr (&Sread_event
);
1914 defsubr (&Sget_file_char
);
1915 defsubr (&Smapatoms
);
1917 DEFVAR_LISP ("obarray", &Vobarray
,
1918 "Symbol table for use by `intern' and `read'.\n\
1919 It is a vector whose length ought to be prime for best results.\n\
1920 The vector's contents don't make sense if examined from Lisp programs;\n\
1921 to find all the symbols in an obarray, use `mapatoms'.");
1923 DEFVAR_LISP ("values", &Vvalues
,
1924 "List of values of all expressions which were read, evaluated and printed.\n\
1925 Order is reverse chronological.");
1927 DEFVAR_LISP ("standard-input", &Vstandard_input
,
1928 "Stream for read to get input from.\n\
1929 See documentation of `read' for possible values.");
1930 Vstandard_input
= Qt
;
1932 DEFVAR_LISP ("load-path", &Vload_path
,
1933 "*List of directories to search for files to load.\n\
1934 Each element is a string (directory name) or nil (try default directory).\n\
1935 Initialized based on EMACSLOADPATH environment variable, if any,\n\
1936 otherwise to default specified by file `paths.h' when Emacs was built.");
1938 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
1939 "Non-nil iff inside of `load'.");
1941 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
1942 "An alist of expressions to be evalled when particular files are loaded.\n\
1943 Each element looks like (FILENAME FORMS...).\n\
1944 When `load' is run and the file-name argument is FILENAME,\n\
1945 the FORMS in the corresponding element are executed at the end of loading.\n\n\
1946 FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
1947 with no directory specified, since that is how `load' is normally called.\n\
1948 An error in FORMS does not undo the load,\n\
1949 but does prevent execution of the rest of the FORMS.");
1950 Vafter_load_alist
= Qnil
;
1952 DEFVAR_LISP ("load-history", &Vload_history
,
1953 "Alist mapping source file names to symbols and features.\n\
1954 Each alist element is a list that starts with a file name,\n\
1955 except for one element (optional) that starts with nil and describes\n\
1956 definitions evaluated from buffers not visiting files.\n\
1957 The remaining elements of each list are symbols defined as functions\n\
1958 or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
1959 Vload_history
= Qnil
;
1961 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
1962 "Used for internal purposes by `load'.");
1963 Vcurrent_load_list
= Qnil
;
1965 load_descriptor_list
= Qnil
;
1966 staticpro (&load_descriptor_list
);
1968 Qcurrent_load_list
= intern ("current-load-list");
1969 staticpro (&Qcurrent_load_list
);
1971 Qstandard_input
= intern ("standard-input");
1972 staticpro (&Qstandard_input
);
1974 Qread_char
= intern ("read-char");
1975 staticpro (&Qread_char
);
1977 Qget_file_char
= intern ("get-file-char");
1978 staticpro (&Qget_file_char
);
1980 Qascii_character
= intern ("ascii-character");
1981 staticpro (&Qascii_character
);
1983 Qload
= intern ("load");