1 /* Lisp parsing and input streams.
2 Copyright (C) 1985, 86, 87, 88, 89, 93, 94, 95, 97, 98, 99, 2000, 2001
3 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, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
25 #include <sys/types.h>
30 #include "intervals.h"
36 #include "termhooks.h"
40 #include <sys/inode.h>
45 #include <unistd.h> /* to get X_OK */
62 #endif /* HAVE_SETLOCALE */
69 #define file_offset off_t
70 #define file_tell ftello
72 #define file_offset long
73 #define file_tell ftell
80 Lisp_Object Qread_char
, Qget_file_char
, Qstandard_input
, Qcurrent_load_list
;
81 Lisp_Object Qvariable_documentation
, Vvalues
, Vstandard_input
, Vafter_load_alist
;
82 Lisp_Object Qascii_character
, Qload
, Qload_file_name
;
83 Lisp_Object Qbackquote
, Qcomma
, Qcomma_at
, Qcomma_dot
, Qfunction
;
84 Lisp_Object Qinhibit_file_name_operation
;
86 extern Lisp_Object Qevent_symbol_element_mask
;
87 extern Lisp_Object Qfile_exists_p
;
89 /* non-zero if inside `load' */
92 /* Directory in which the sources were found. */
93 Lisp_Object Vsource_directory
;
95 /* Search path and suffixes for files to be loaded. */
96 Lisp_Object Vload_path
, Vload_suffixes
, default_suffixes
;
98 /* File name of user's init file. */
99 Lisp_Object Vuser_init_file
;
101 /* This is the user-visible association list that maps features to
102 lists of defs in their load files. */
103 Lisp_Object Vload_history
;
105 /* This is used to build the load history. */
106 Lisp_Object Vcurrent_load_list
;
108 /* List of files that were preloaded. */
109 Lisp_Object Vpreloaded_file_list
;
111 /* Name of file actually being read by `load'. */
112 Lisp_Object Vload_file_name
;
114 /* Function to use for reading, in `load' and friends. */
115 Lisp_Object Vload_read_function
;
117 /* The association list of objects read with the #n=object form.
118 Each member of the list has the form (n . object), and is used to
119 look up the object for the corresponding #n# construct.
120 It must be set to nil before all top-level calls to read0. */
121 Lisp_Object read_objects
;
123 /* Nonzero means load should forcibly load all dynamic doc strings. */
124 static int load_force_doc_strings
;
126 /* Nonzero means read should convert strings to unibyte. */
127 static int load_convert_to_unibyte
;
129 /* Function to use for loading an Emacs lisp source file (not
130 compiled) instead of readevalloop. */
131 Lisp_Object Vload_source_file_function
;
133 /* List of all DEFVAR_BOOL variables. Used by the byte optimizer. */
134 Lisp_Object Vbyte_boolean_vars
;
136 /* Whether or not to add a `read-positions' property to symbols
138 Lisp_Object Vread_with_symbol_positions
;
140 /* List of (SYMBOL . POSITION) accumulated so far. */
141 Lisp_Object Vread_symbol_positions_list
;
143 /* List of descriptors now open for Fload. */
144 static Lisp_Object load_descriptor_list
;
146 /* File for get_file_char to read from. Use by load. */
147 static FILE *instream
;
149 /* When nonzero, read conses in pure space */
150 static int read_pure
;
152 /* For use within read-from-string (this reader is non-reentrant!!) */
153 static int read_from_string_index
;
154 static int read_from_string_index_byte
;
155 static int read_from_string_limit
;
157 /* Number of bytes left to read in the buffer character
158 that `readchar' has already advanced over. */
159 static int readchar_backlog
;
160 /* Number of characters read in the current call to Fread or
161 Fread_from_string. */
162 static int readchar_count
;
164 /* This contains the last string skipped with #@. */
165 static char *saved_doc_string
;
166 /* Length of buffer allocated in saved_doc_string. */
167 static int saved_doc_string_size
;
168 /* Length of actual data in saved_doc_string. */
169 static int saved_doc_string_length
;
170 /* This is the file position that string came from. */
171 static file_offset saved_doc_string_position
;
173 /* This contains the previous string skipped with #@.
174 We copy it from saved_doc_string when a new string
175 is put in saved_doc_string. */
176 static char *prev_saved_doc_string
;
177 /* Length of buffer allocated in prev_saved_doc_string. */
178 static int prev_saved_doc_string_size
;
179 /* Length of actual data in prev_saved_doc_string. */
180 static int prev_saved_doc_string_length
;
181 /* This is the file position that string came from. */
182 static file_offset prev_saved_doc_string_position
;
184 /* Nonzero means inside a new-style backquote
185 with no surrounding parentheses.
186 Fread initializes this to zero, so we need not specbind it
187 or worry about what happens to it when there is an error. */
188 static int new_backquote_flag
;
190 /* A list of file names for files being loaded in Fload. Used to
191 check for recursive loads. */
193 static Lisp_Object Vloads_in_progress
;
195 /* Non-zero means load dangerous compiled Lisp files. */
197 int load_dangerous_libraries
;
199 /* A regular expression used to detect files compiled with Emacs. */
201 static Lisp_Object Vbytecomp_version_regexp
;
203 static void to_multibyte
P_ ((char **, char **, int *));
204 static void readevalloop
P_ ((Lisp_Object
, FILE*, Lisp_Object
,
205 Lisp_Object (*) (), int,
206 Lisp_Object
, Lisp_Object
));
207 static Lisp_Object load_unwind
P_ ((Lisp_Object
));
208 static Lisp_Object load_descriptor_unwind
P_ ((Lisp_Object
));
211 /* Handle unreading and rereading of characters.
212 Write READCHAR to read a character,
213 UNREAD(c) to unread c to be read again.
215 The READCHAR and UNREAD macros are meant for reading/unreading a
216 byte code; they do not handle multibyte characters. The caller
217 should manage them if necessary.
219 [ Actually that seems to be a lie; READCHAR will definitely read
220 multibyte characters from buffer sources, at least. Is the
221 comment just out of date?
222 -- Colin Walters <walters@gnu.org>, 22 May 2002 16:36:50 -0400 ]
225 #define READCHAR readchar (readcharfun)
226 #define UNREAD(c) unreadchar (readcharfun, c)
229 readchar (readcharfun
)
230 Lisp_Object readcharfun
;
237 if (BUFFERP (readcharfun
))
239 register struct buffer
*inbuffer
= XBUFFER (readcharfun
);
241 int pt_byte
= BUF_PT_BYTE (inbuffer
);
242 int orig_pt_byte
= pt_byte
;
244 if (readchar_backlog
> 0)
245 /* We get the address of the byte just passed,
246 which is the last byte of the character.
247 The other bytes in this character are consecutive with it,
248 because the gap can't be in the middle of a character. */
249 return *(BUF_BYTE_ADDRESS (inbuffer
, BUF_PT_BYTE (inbuffer
) - 1)
250 - --readchar_backlog
);
252 if (pt_byte
>= BUF_ZV_BYTE (inbuffer
))
255 readchar_backlog
= -1;
257 if (! NILP (inbuffer
->enable_multibyte_characters
))
259 /* Fetch the character code from the buffer. */
260 unsigned char *p
= BUF_BYTE_ADDRESS (inbuffer
, pt_byte
);
261 BUF_INC_POS (inbuffer
, pt_byte
);
262 c
= STRING_CHAR (p
, pt_byte
- orig_pt_byte
);
266 c
= BUF_FETCH_BYTE (inbuffer
, pt_byte
);
269 SET_BUF_PT_BOTH (inbuffer
, BUF_PT (inbuffer
) + 1, pt_byte
);
273 if (MARKERP (readcharfun
))
275 register struct buffer
*inbuffer
= XMARKER (readcharfun
)->buffer
;
277 int bytepos
= marker_byte_position (readcharfun
);
278 int orig_bytepos
= bytepos
;
280 if (readchar_backlog
> 0)
281 /* We get the address of the byte just passed,
282 which is the last byte of the character.
283 The other bytes in this character are consecutive with it,
284 because the gap can't be in the middle of a character. */
285 return *(BUF_BYTE_ADDRESS (inbuffer
, XMARKER (readcharfun
)->bytepos
- 1)
286 - --readchar_backlog
);
288 if (bytepos
>= BUF_ZV_BYTE (inbuffer
))
291 readchar_backlog
= -1;
293 if (! NILP (inbuffer
->enable_multibyte_characters
))
295 /* Fetch the character code from the buffer. */
296 unsigned char *p
= BUF_BYTE_ADDRESS (inbuffer
, bytepos
);
297 BUF_INC_POS (inbuffer
, bytepos
);
298 c
= STRING_CHAR (p
, bytepos
- orig_bytepos
);
302 c
= BUF_FETCH_BYTE (inbuffer
, bytepos
);
306 XMARKER (readcharfun
)->bytepos
= bytepos
;
307 XMARKER (readcharfun
)->charpos
++;
312 if (EQ (readcharfun
, Qlambda
))
313 return read_bytecode_char (0);
315 if (EQ (readcharfun
, Qget_file_char
))
319 /* Interrupted reads have been observed while reading over the network */
320 while (c
== EOF
&& ferror (instream
) && errno
== EINTR
)
329 if (STRINGP (readcharfun
))
331 if (read_from_string_index
>= read_from_string_limit
)
334 FETCH_STRING_CHAR_ADVANCE (c
, readcharfun
,
335 read_from_string_index
,
336 read_from_string_index_byte
);
341 tem
= call0 (readcharfun
);
348 /* Unread the character C in the way appropriate for the stream READCHARFUN.
349 If the stream is a user function, call it with the char as argument. */
352 unreadchar (readcharfun
, c
)
353 Lisp_Object readcharfun
;
358 /* Don't back up the pointer if we're unreading the end-of-input mark,
359 since readchar didn't advance it when we read it. */
361 else if (BUFFERP (readcharfun
))
363 struct buffer
*b
= XBUFFER (readcharfun
);
364 int bytepos
= BUF_PT_BYTE (b
);
366 if (readchar_backlog
>= 0)
371 if (! NILP (b
->enable_multibyte_characters
))
372 BUF_DEC_POS (b
, bytepos
);
376 BUF_PT_BYTE (b
) = bytepos
;
379 else if (MARKERP (readcharfun
))
381 struct buffer
*b
= XMARKER (readcharfun
)->buffer
;
382 int bytepos
= XMARKER (readcharfun
)->bytepos
;
384 if (readchar_backlog
>= 0)
388 XMARKER (readcharfun
)->charpos
--;
389 if (! NILP (b
->enable_multibyte_characters
))
390 BUF_DEC_POS (b
, bytepos
);
394 XMARKER (readcharfun
)->bytepos
= bytepos
;
397 else if (STRINGP (readcharfun
))
399 read_from_string_index
--;
400 read_from_string_index_byte
401 = string_char_to_byte (readcharfun
, read_from_string_index
);
403 else if (EQ (readcharfun
, Qlambda
))
404 read_bytecode_char (1);
405 else if (EQ (readcharfun
, Qget_file_char
))
406 ungetc (c
, instream
);
408 call1 (readcharfun
, make_number (c
));
411 static Lisp_Object read_internal_start
P_ ((Lisp_Object
, Lisp_Object
,
413 static Lisp_Object read0
P_ ((Lisp_Object
));
414 static Lisp_Object read1
P_ ((Lisp_Object
, int *, int));
416 static Lisp_Object read_list
P_ ((int, Lisp_Object
));
417 static Lisp_Object read_vector
P_ ((Lisp_Object
, int));
418 static int read_multibyte
P_ ((int, Lisp_Object
));
420 static Lisp_Object substitute_object_recurse
P_ ((Lisp_Object
, Lisp_Object
,
422 static void substitute_object_in_subtree
P_ ((Lisp_Object
,
424 static void substitute_in_interval
P_ ((INTERVAL
, Lisp_Object
));
427 /* Get a character from the tty. */
429 extern Lisp_Object
read_char ();
431 /* Read input events until we get one that's acceptable for our purposes.
433 If NO_SWITCH_FRAME is non-zero, switch-frame events are stashed
434 until we get a character we like, and then stuffed into
437 If ASCII_REQUIRED is non-zero, we check function key events to see
438 if the unmodified version of the symbol has a Qascii_character
439 property, and use that character, if present.
441 If ERROR_NONASCII is non-zero, we signal an error if the input we
442 get isn't an ASCII character with modifiers. If it's zero but
443 ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
446 If INPUT_METHOD is nonzero, we invoke the current input method
447 if the character warrants that. */
450 read_filtered_event (no_switch_frame
, ascii_required
, error_nonascii
,
452 int no_switch_frame
, ascii_required
, error_nonascii
, input_method
;
454 register Lisp_Object val
, delayed_switch_frame
;
456 #ifdef HAVE_WINDOW_SYSTEM
457 if (display_hourglass_p
)
461 delayed_switch_frame
= Qnil
;
463 /* Read until we get an acceptable event. */
465 val
= read_char (0, 0, 0,
466 (input_method
? Qnil
: Qt
),
472 /* switch-frame events are put off until after the next ASCII
473 character. This is better than signaling an error just because
474 the last characters were typed to a separate minibuffer frame,
475 for example. Eventually, some code which can deal with
476 switch-frame events will read it and process it. */
478 && EVENT_HAS_PARAMETERS (val
)
479 && EQ (EVENT_HEAD (val
), Qswitch_frame
))
481 delayed_switch_frame
= val
;
487 /* Convert certain symbols to their ASCII equivalents. */
490 Lisp_Object tem
, tem1
;
491 tem
= Fget (val
, Qevent_symbol_element_mask
);
494 tem1
= Fget (Fcar (tem
), Qascii_character
);
495 /* Merge this symbol's modifier bits
496 with the ASCII equivalent of its basic code. */
498 XSETFASTINT (val
, XINT (tem1
) | XINT (Fcar (Fcdr (tem
))));
502 /* If we don't have a character now, deal with it appropriately. */
507 Vunread_command_events
= Fcons (val
, Qnil
);
508 error ("Non-character input-event");
515 if (! NILP (delayed_switch_frame
))
516 unread_switch_frame
= delayed_switch_frame
;
520 #ifdef HAVE_WINDOW_SYSTEM
521 if (display_hourglass_p
)
530 DEFUN ("read-char", Fread_char
, Sread_char
, 0, 2, 0,
531 doc
: /* Read a character from the command input (keyboard or macro).
532 It is returned as a number.
533 If the user generates an event which is not a character (i.e. a mouse
534 click or function key event), `read-char' signals an error. As an
535 exception, switch-frame events are put off until non-ASCII events can
537 If you want to read non-character events, or ignore them, call
538 `read-event' or `read-char-exclusive' instead.
540 If the optional argument PROMPT is non-nil, display that as a prompt.
541 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
542 input method is turned on in the current buffer, that input method
543 is used for reading a character. */)
544 (prompt
, inherit_input_method
)
545 Lisp_Object prompt
, inherit_input_method
;
548 message_with_string ("%s", prompt
, 0);
549 return read_filtered_event (1, 1, 1, ! NILP (inherit_input_method
));
552 DEFUN ("read-event", Fread_event
, Sread_event
, 0, 2, 0,
553 doc
: /* Read an event object from the input stream.
554 If the optional argument PROMPT is non-nil, display that as a prompt.
555 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
556 input method is turned on in the current buffer, that input method
557 is used for reading a character. */)
558 (prompt
, inherit_input_method
)
559 Lisp_Object prompt
, inherit_input_method
;
562 message_with_string ("%s", prompt
, 0);
563 return read_filtered_event (0, 0, 0, ! NILP (inherit_input_method
));
566 DEFUN ("read-char-exclusive", Fread_char_exclusive
, Sread_char_exclusive
, 0, 2, 0,
567 doc
: /* Read a character from the command input (keyboard or macro).
568 It is returned as a number. Non-character events are ignored.
570 If the optional argument PROMPT is non-nil, display that as a prompt.
571 If the optional argument INHERIT-INPUT-METHOD is non-nil and some
572 input method is turned on in the current buffer, that input method
573 is used for reading a character. */)
574 (prompt
, inherit_input_method
)
575 Lisp_Object prompt
, inherit_input_method
;
578 message_with_string ("%s", prompt
, 0);
579 return read_filtered_event (1, 1, 0, ! NILP (inherit_input_method
));
582 DEFUN ("get-file-char", Fget_file_char
, Sget_file_char
, 0, 0, 0,
583 doc
: /* Don't use this yourself. */)
586 register Lisp_Object val
;
587 XSETINT (val
, getc (instream
));
593 /* Value is non-zero if the file asswociated with file descriptor FD
594 is a compiled Lisp file that's safe to load. Only files compiled
595 with Emacs are safe to load. Files compiled with XEmacs can lead
596 to a crash in Fbyte_code because of an incompatible change in the
607 /* Read the first few bytes from the file, and look for a line
608 specifying the byte compiler version used. */
609 nbytes
= emacs_read (fd
, buf
, sizeof buf
- 1);
614 /* Skip to the next newline, skipping over the initial `ELC'
615 with NUL bytes following it. */
616 for (i
= 0; i
< nbytes
&& buf
[i
] != '\n'; ++i
)
620 && fast_c_string_match_ignore_case (Vbytecomp_version_regexp
,
625 lseek (fd
, 0, SEEK_SET
);
630 /* Callback for record_unwind_protect. Restore the old load list OLD,
631 after loading a file successfully. */
634 record_load_unwind (old
)
637 return Vloads_in_progress
= old
;
641 DEFUN ("load", Fload
, Sload
, 1, 5, 0,
642 doc
: /* Execute a file of Lisp code named FILE.
643 First try FILE with `.elc' appended, then try with `.el',
644 then try FILE unmodified (the exact suffixes are determined by
645 `load-suffixes'). Environment variable references in FILE
646 are replaced with their values by calling `substitute-in-file-name'.
647 This function searches the directories in `load-path'.
648 If optional second arg NOERROR is non-nil,
649 report no error if FILE doesn't exist.
650 Print messages at start and end of loading unless
651 optional third arg NOMESSAGE is non-nil.
652 If optional fourth arg NOSUFFIX is non-nil, don't try adding
653 suffixes `.elc' or `.el' to the specified name FILE.
654 If optional fifth arg MUST-SUFFIX is non-nil, insist on
655 the suffix `.elc' or `.el'; don't accept just FILE unless
656 it ends in one of those suffixes or includes a directory name.
657 Return t if file exists. */)
658 (file
, noerror
, nomessage
, nosuffix
, must_suffix
)
659 Lisp_Object file
, noerror
, nomessage
, nosuffix
, must_suffix
;
661 register FILE *stream
;
662 register int fd
= -1;
663 register Lisp_Object lispstream
;
664 int count
= SPECPDL_INDEX ();
667 Lisp_Object found
, efound
;
668 /* 1 means we printed the ".el is newer" message. */
670 /* 1 means we are loading a compiled file. */
681 /* If file name is magic, call the handler. */
682 /* This shouldn't be necessary any more now that `openp' handles it right.
683 handler = Ffind_file_name_handler (file, Qload);
685 return call5 (handler, Qload, file, noerror, nomessage, nosuffix); */
687 /* Do this after the handler to avoid
688 the need to gcpro noerror, nomessage and nosuffix.
689 (Below here, we care only whether they are nil or not.)
690 The presence of this call is the result of a historical accident:
691 it used to be in every file-operations and when it got removed
692 everywhere, it accidentally stayed here. Since then, enough people
693 supposedly have things like (load "$PROJECT/foo.el") in their .emacs
694 that it seemed risky to remove. */
695 file
= Fsubstitute_in_file_name (file
);
697 /* Avoid weird lossage with null string as arg,
698 since it would try to load a directory as a Lisp file */
699 if (SCHARS (file
) > 0)
701 int size
= SBYTES (file
);
706 if (! NILP (must_suffix
))
708 /* Don't insist on adding a suffix if FILE already ends with one. */
710 && !strcmp (SDATA (file
) + size
- 3, ".el"))
713 && !strcmp (SDATA (file
) + size
- 4, ".elc"))
715 /* Don't insist on adding a suffix
716 if the argument includes a directory name. */
717 else if (! NILP (Ffile_name_directory (file
)))
721 fd
= openp (Vload_path
, file
,
722 (!NILP (nosuffix
) ? Qnil
723 : !NILP (must_suffix
) ? Vload_suffixes
724 : Fappend (2, (tmp
[0] = Vload_suffixes
,
725 tmp
[1] = default_suffixes
,
735 Fsignal (Qfile_error
, Fcons (build_string ("Cannot open load file"),
736 Fcons (file
, Qnil
)));
741 /* Tell startup.el whether or not we found the user's init file. */
742 if (EQ (Qt
, Vuser_init_file
))
743 Vuser_init_file
= found
;
745 /* If FD is -2, that means openp found a magic file. */
748 if (NILP (Fequal (found
, file
)))
749 /* If FOUND is a different file name from FILE,
750 find its handler even if we have already inhibited
751 the `load' operation on FILE. */
752 handler
= Ffind_file_name_handler (found
, Qt
);
754 handler
= Ffind_file_name_handler (found
, Qload
);
755 if (! NILP (handler
))
756 return call5 (handler
, Qload
, found
, noerror
, nomessage
, Qt
);
759 /* Check if we're stuck in a recursive load cycle.
761 2000-09-21: It's not possible to just check for the file loaded
762 being a member of Vloads_in_progress. This fails because of the
763 way the byte compiler currently works; `provide's are not
764 evaluted, see font-lock.el/jit-lock.el as an example. This
765 leads to a certain amount of ``normal'' recursion.
767 Also, just loading a file recursively is not always an error in
768 the general case; the second load may do something different. */
772 for (tem
= Vloads_in_progress
; CONSP (tem
); tem
= XCDR (tem
))
773 if (!NILP (Fequal (found
, XCAR (tem
))))
776 Fsignal (Qerror
, Fcons (build_string ("Recursive load"),
777 Fcons (found
, Vloads_in_progress
)));
778 record_unwind_protect (record_load_unwind
, Vloads_in_progress
);
779 Vloads_in_progress
= Fcons (found
, Vloads_in_progress
);
782 if (!bcmp (SDATA (found
) + SBYTES (found
) - 4,
784 /* Load .elc files directly, but not when they are
785 remote and have no handler! */
792 if (!safe_to_load_p (fd
))
795 if (!load_dangerous_libraries
)
799 error ("File `%s' was not compiled in Emacs",
802 else if (!NILP (nomessage
))
803 message_with_string ("File `%s' not compiled in Emacs", found
, 1);
809 efound
= ENCODE_FILE (found
);
814 stat ((char *)SDATA (efound
), &s1
);
815 SSET (efound
, SBYTES (efound
) - 1, 0);
816 result
= stat ((char *)SDATA (efound
), &s2
);
817 SSET (efound
, SBYTES (efound
) - 1, 'c');
820 if (result
>= 0 && (unsigned) s1
.st_mtime
< (unsigned) s2
.st_mtime
)
822 /* Make the progress messages mention that source is newer. */
825 /* If we won't print another message, mention this anyway. */
826 if (!NILP (nomessage
))
829 file
= Fsubstring (found
, make_number (0), make_number (-1));
830 message_with_string ("Source file `%s' newer than byte-compiled file",
831 file
, STRING_MULTIBYTE (file
));
838 /* We are loading a source file (*.el). */
839 if (!NILP (Vload_source_file_function
))
845 val
= call4 (Vload_source_file_function
, found
, file
,
846 NILP (noerror
) ? Qnil
: Qt
,
847 NILP (nomessage
) ? Qnil
: Qt
);
848 return unbind_to (count
, val
);
855 efound
= ENCODE_FILE (found
);
856 stream
= fopen ((char *) SDATA (efound
), fmode
);
858 #else /* not WINDOWSNT */
859 stream
= fdopen (fd
, fmode
);
860 #endif /* not WINDOWSNT */
864 error ("Failure to create stdio stream for %s", SDATA (file
));
867 if (! NILP (Vpurify_flag
))
868 Vpreloaded_file_list
= Fcons (file
, Vpreloaded_file_list
);
870 if (NILP (nomessage
))
873 message_with_string ("Loading %s (compiled; note unsafe, not compiled in Emacs)...",
876 message_with_string ("Loading %s (source)...", file
, 1);
878 message_with_string ("Loading %s (compiled; note, source file is newer)...",
880 else /* The typical case; compiled file newer than source file. */
881 message_with_string ("Loading %s...", file
, 1);
885 lispstream
= Fcons (Qnil
, Qnil
);
886 XSETCARFASTINT (lispstream
, (EMACS_UINT
)stream
>> 16);
887 XSETCDRFASTINT (lispstream
, (EMACS_UINT
)stream
& 0xffff);
888 record_unwind_protect (load_unwind
, lispstream
);
889 record_unwind_protect (load_descriptor_unwind
, load_descriptor_list
);
890 specbind (Qload_file_name
, found
);
891 specbind (Qinhibit_file_name_operation
, Qnil
);
893 = Fcons (make_number (fileno (stream
)), load_descriptor_list
);
895 readevalloop (Qget_file_char
, stream
, file
, Feval
, 0, Qnil
, Qnil
);
896 unbind_to (count
, Qnil
);
898 /* Run any load-hooks for this file. */
899 temp
= Fassoc (file
, Vafter_load_alist
);
901 Fprogn (Fcdr (temp
));
904 if (saved_doc_string
)
905 free (saved_doc_string
);
906 saved_doc_string
= 0;
907 saved_doc_string_size
= 0;
909 if (prev_saved_doc_string
)
910 xfree (prev_saved_doc_string
);
911 prev_saved_doc_string
= 0;
912 prev_saved_doc_string_size
= 0;
914 if (!noninteractive
&& NILP (nomessage
))
917 message_with_string ("Loading %s (compiled; note unsafe, not compiled in Emacs)...done",
920 message_with_string ("Loading %s (source)...done", file
, 1);
922 message_with_string ("Loading %s (compiled; note, source file is newer)...done",
924 else /* The typical case; compiled file newer than source file. */
925 message_with_string ("Loading %s...done", file
, 1);
932 load_unwind (stream
) /* used as unwind-protect function in load */
935 fclose ((FILE *) (XFASTINT (XCAR (stream
)) << 16
936 | XFASTINT (XCDR (stream
))));
937 if (--load_in_progress
< 0) load_in_progress
= 0;
942 load_descriptor_unwind (oldlist
)
945 load_descriptor_list
= oldlist
;
949 /* Close all descriptors in use for Floads.
950 This is used when starting a subprocess. */
957 for (tail
= load_descriptor_list
; !NILP (tail
); tail
= XCDR (tail
))
958 emacs_close (XFASTINT (XCAR (tail
)));
963 complete_filename_p (pathname
)
964 Lisp_Object pathname
;
966 register const unsigned char *s
= SDATA (pathname
);
967 return (IS_DIRECTORY_SEP (s
[0])
968 || (SCHARS (pathname
) > 2
969 && IS_DEVICE_SEP (s
[1]) && IS_DIRECTORY_SEP (s
[2]))
979 DEFUN ("locate-file-internal", Flocate_file_internal
, Slocate_file_internal
, 2, 4, 0,
980 doc
: /* Search for FILENAME through PATH.
981 If SUFFIXES is non-nil, it should be a list of suffixes to append to
982 file name when searching.
983 If non-nil, PREDICATE is used instead of `file-readable-p'.
984 PREDICATE can also be an integer to pass to the access(2) function,
985 in which case file-name-handlers are ignored. */)
986 (filename
, path
, suffixes
, predicate
)
987 Lisp_Object filename
, path
, suffixes
, predicate
;
990 int fd
= openp (path
, filename
, suffixes
, &file
, predicate
);
991 if (NILP (predicate
) && fd
> 0)
997 /* Search for a file whose name is STR, looking in directories
998 in the Lisp list PATH, and trying suffixes from SUFFIX.
999 On success, returns a file descriptor. On failure, returns -1.
1001 SUFFIXES is a list of strings containing possible suffixes.
1002 The empty suffix is automatically added iff the list is empty.
1004 PREDICATE non-nil means don't open the files,
1005 just look for one that satisfies the predicate. In this case,
1006 returns 1 on success. The predicate can be a lisp function or
1007 an integer to pass to `access' (in which case file-name-handlers
1010 If STOREPTR is nonzero, it points to a slot where the name of
1011 the file actually found should be stored as a Lisp string.
1012 nil is stored there on failure.
1014 If the file we find is remote, return -2
1015 but store the found remote file name in *STOREPTR. */
1018 openp (path
, str
, suffixes
, storeptr
, predicate
)
1019 Lisp_Object path
, str
;
1020 Lisp_Object suffixes
;
1021 Lisp_Object
*storeptr
;
1022 Lisp_Object predicate
;
1027 register char *fn
= buf
;
1030 Lisp_Object filename
;
1032 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
1033 Lisp_Object string
, tail
, encoded_fn
;
1034 int max_suffix_len
= 0;
1036 for (tail
= suffixes
; CONSP (tail
); tail
= XCDR (tail
))
1038 CHECK_STRING_CAR (tail
);
1039 max_suffix_len
= max (max_suffix_len
,
1040 SBYTES (XCAR (tail
)));
1043 string
= filename
= Qnil
;
1044 GCPRO6 (str
, string
, filename
, path
, suffixes
, encoded_fn
);
1049 if (complete_filename_p (str
))
1052 for (; CONSP (path
); path
= XCDR (path
))
1054 filename
= Fexpand_file_name (str
, XCAR (path
));
1055 if (!complete_filename_p (filename
))
1056 /* If there are non-absolute elts in PATH (eg ".") */
1057 /* Of course, this could conceivably lose if luser sets
1058 default-directory to be something non-absolute... */
1060 filename
= Fexpand_file_name (filename
, current_buffer
->directory
);
1061 if (!complete_filename_p (filename
))
1062 /* Give up on this path element! */
1066 /* Calculate maximum size of any filename made from
1067 this path element/specified file name and any possible suffix. */
1068 want_size
= max_suffix_len
+ SBYTES (filename
) + 1;
1069 if (fn_size
< want_size
)
1070 fn
= (char *) alloca (fn_size
= 100 + want_size
);
1072 /* Loop over suffixes. */
1073 for (tail
= NILP (suffixes
) ? default_suffixes
: suffixes
;
1074 CONSP (tail
); tail
= XCDR (tail
))
1076 int lsuffix
= SBYTES (XCAR (tail
));
1077 Lisp_Object handler
;
1080 /* Concatenate path element/specified name with the suffix.
1081 If the directory starts with /:, remove that. */
1082 if (SCHARS (filename
) > 2
1083 && SREF (filename
, 0) == '/'
1084 && SREF (filename
, 1) == ':')
1086 strncpy (fn
, SDATA (filename
) + 2,
1087 SBYTES (filename
) - 2);
1088 fn
[SBYTES (filename
) - 2] = 0;
1092 strncpy (fn
, SDATA (filename
),
1094 fn
[SBYTES (filename
)] = 0;
1097 if (lsuffix
!= 0) /* Bug happens on CCI if lsuffix is 0. */
1098 strncat (fn
, SDATA (XCAR (tail
)), lsuffix
);
1100 /* Check that the file exists and is not a directory. */
1101 /* We used to only check for handlers on non-absolute file names:
1105 handler = Ffind_file_name_handler (filename, Qfile_exists_p);
1106 It's not clear why that was the case and it breaks things like
1107 (load "/bar.el") where the file is actually "/bar.el.gz". */
1108 handler
= Ffind_file_name_handler (filename
, Qfile_exists_p
);
1109 string
= build_string (fn
);
1110 if ((!NILP (handler
) || !NILP (predicate
)) && !NATNUMP (predicate
))
1112 if (NILP (predicate
))
1113 exists
= !NILP (Ffile_readable_p (string
));
1115 exists
= !NILP (call1 (predicate
, string
));
1116 if (exists
&& !NILP (Ffile_directory_p (string
)))
1121 /* We succeeded; return this descriptor and filename. */
1132 encoded_fn
= ENCODE_FILE (string
);
1133 pfn
= SDATA (encoded_fn
);
1134 exists
= (stat (pfn
, &st
) >= 0
1135 && (st
.st_mode
& S_IFMT
) != S_IFDIR
);
1138 /* Check that we can access or open it. */
1139 if (NATNUMP (predicate
))
1140 fd
= (access (pfn
, XFASTINT (predicate
)) == 0) ? 1 : -1;
1142 fd
= emacs_open (pfn
, O_RDONLY
, 0);
1146 /* We succeeded; return this descriptor and filename. */
1164 /* Merge the list we've accumulated of globals from the current input source
1165 into the load_history variable. The details depend on whether
1166 the source has an associated file name or not. */
1169 build_load_history (stream
, source
)
1173 register Lisp_Object tail
, prev
, newelt
;
1174 register Lisp_Object tem
, tem2
;
1175 register int foundit
, loading
;
1177 loading
= stream
|| !NARROWED
;
1179 tail
= Vload_history
;
1182 while (CONSP (tail
))
1186 /* Find the feature's previous assoc list... */
1187 if (!NILP (Fequal (source
, Fcar (tem
))))
1191 /* If we're loading, remove it. */
1195 Vload_history
= XCDR (tail
);
1197 Fsetcdr (prev
, XCDR (tail
));
1200 /* Otherwise, cons on new symbols that are not already members. */
1203 tem2
= Vcurrent_load_list
;
1205 while (CONSP (tem2
))
1207 newelt
= XCAR (tem2
);
1209 if (NILP (Fmember (newelt
, tem
)))
1210 Fsetcar (tail
, Fcons (XCAR (tem
),
1211 Fcons (newelt
, XCDR (tem
))));
1224 /* If we're loading, cons the new assoc onto the front of load-history,
1225 the most-recently-loaded position. Also do this if we didn't find
1226 an existing member for the current source. */
1227 if (loading
|| !foundit
)
1228 Vload_history
= Fcons (Fnreverse (Vcurrent_load_list
),
1233 unreadpure (junk
) /* Used as unwind-protect function in readevalloop */
1241 readevalloop_1 (old
)
1244 load_convert_to_unibyte
= ! NILP (old
);
1248 /* Signal an `end-of-file' error, if possible with file name
1252 end_of_file_error ()
1256 if (STRINGP (Vload_file_name
))
1257 data
= Fcons (Vload_file_name
, Qnil
);
1261 Fsignal (Qend_of_file
, data
);
1264 /* UNIBYTE specifies how to set load_convert_to_unibyte
1265 for this invocation.
1266 READFUN, if non-nil, is used instead of `read'. */
1269 readevalloop (readcharfun
, stream
, sourcename
, evalfun
, printflag
, unibyte
, readfun
)
1270 Lisp_Object readcharfun
;
1272 Lisp_Object sourcename
;
1273 Lisp_Object (*evalfun
) ();
1275 Lisp_Object unibyte
, readfun
;
1278 register Lisp_Object val
;
1279 int count
= SPECPDL_INDEX ();
1280 struct gcpro gcpro1
;
1281 struct buffer
*b
= 0;
1282 int continue_reading_p
;
1284 if (BUFFERP (readcharfun
))
1285 b
= XBUFFER (readcharfun
);
1286 else if (MARKERP (readcharfun
))
1287 b
= XMARKER (readcharfun
)->buffer
;
1289 specbind (Qstandard_input
, readcharfun
);
1290 specbind (Qcurrent_load_list
, Qnil
);
1291 record_unwind_protect (readevalloop_1
, load_convert_to_unibyte
? Qt
: Qnil
);
1292 load_convert_to_unibyte
= !NILP (unibyte
);
1294 readchar_backlog
= -1;
1296 GCPRO1 (sourcename
);
1298 LOADHIST_ATTACH (sourcename
);
1300 continue_reading_p
= 1;
1301 while (continue_reading_p
)
1303 if (b
!= 0 && NILP (b
->name
))
1304 error ("Reading from killed buffer");
1310 while ((c
= READCHAR
) != '\n' && c
!= -1);
1315 /* Ignore whitespace here, so we can detect eof. */
1316 if (c
== ' ' || c
== '\t' || c
== '\n' || c
== '\f' || c
== '\r')
1319 if (!NILP (Vpurify_flag
) && c
== '(')
1321 int count1
= SPECPDL_INDEX ();
1322 record_unwind_protect (unreadpure
, Qnil
);
1323 val
= read_list (-1, readcharfun
);
1324 unbind_to (count1
, Qnil
);
1329 read_objects
= Qnil
;
1330 if (!NILP (readfun
))
1332 val
= call1 (readfun
, readcharfun
);
1334 /* If READCHARFUN has set point to ZV, we should
1335 stop reading, even if the form read sets point
1336 to a different value when evaluated. */
1337 if (BUFFERP (readcharfun
))
1339 struct buffer
*b
= XBUFFER (readcharfun
);
1340 if (BUF_PT (b
) == BUF_ZV (b
))
1341 continue_reading_p
= 0;
1344 else if (! NILP (Vload_read_function
))
1345 val
= call1 (Vload_read_function
, readcharfun
);
1347 val
= read_internal_start (readcharfun
, Qnil
, Qnil
);
1350 val
= (*evalfun
) (val
);
1354 Vvalues
= Fcons (val
, Vvalues
);
1355 if (EQ (Vstandard_output
, Qt
))
1362 build_load_history (stream
, sourcename
);
1365 unbind_to (count
, Qnil
);
1368 DEFUN ("eval-buffer", Feval_buffer
, Seval_buffer
, 0, 5, "",
1369 doc
: /* Execute the current buffer as Lisp code.
1370 Programs can pass two arguments, BUFFER and PRINTFLAG.
1371 BUFFER is the buffer to evaluate (nil means use current buffer).
1372 PRINTFLAG controls printing of output:
1373 nil means discard it; anything else is stream for print.
1375 If the optional third argument FILENAME is non-nil,
1376 it specifies the file name to use for `load-history'.
1377 The optional fourth argument UNIBYTE specifies `load-convert-to-unibyte'
1378 for this invocation.
1380 The optional fifth argument DO-ALLOW-PRINT, if non-nil, specifies that
1381 `print' and related functions should work normally even if PRINTFLAG is nil.
1383 This function preserves the position of point. */)
1384 (buffer
, printflag
, filename
, unibyte
, do_allow_print
)
1385 Lisp_Object buffer
, printflag
, filename
, unibyte
, do_allow_print
;
1387 int count
= SPECPDL_INDEX ();
1388 Lisp_Object tem
, buf
;
1391 buf
= Fcurrent_buffer ();
1393 buf
= Fget_buffer (buffer
);
1395 error ("No such buffer");
1397 if (NILP (printflag
) && NILP (do_allow_print
))
1402 if (NILP (filename
))
1403 filename
= XBUFFER (buf
)->filename
;
1405 specbind (Qstandard_output
, tem
);
1406 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1407 BUF_SET_PT (XBUFFER (buf
), BUF_BEGV (XBUFFER (buf
)));
1408 readevalloop (buf
, 0, filename
, Feval
, !NILP (printflag
), unibyte
, Qnil
);
1409 unbind_to (count
, Qnil
);
1414 DEFUN ("eval-region", Feval_region
, Seval_region
, 2, 4, "r",
1415 doc
: /* Execute the region as Lisp code.
1416 When called from programs, expects two arguments,
1417 giving starting and ending indices in the current buffer
1418 of the text to be executed.
1419 Programs can pass third argument PRINTFLAG which controls output:
1420 nil means discard it; anything else is stream for printing it.
1421 Also the fourth argument READ-FUNCTION, if non-nil, is used
1422 instead of `read' to read each expression. It gets one argument
1423 which is the input stream for reading characters.
1425 This function does not move point. */)
1426 (start
, end
, printflag
, read_function
)
1427 Lisp_Object start
, end
, printflag
, read_function
;
1429 int count
= SPECPDL_INDEX ();
1430 Lisp_Object tem
, cbuf
;
1432 cbuf
= Fcurrent_buffer ();
1434 if (NILP (printflag
))
1438 specbind (Qstandard_output
, tem
);
1440 if (NILP (printflag
))
1441 record_unwind_protect (save_excursion_restore
, save_excursion_save ());
1442 record_unwind_protect (save_restriction_restore
, save_restriction_save ());
1444 /* This both uses start and checks its type. */
1446 Fnarrow_to_region (make_number (BEGV
), end
);
1447 readevalloop (cbuf
, 0, XBUFFER (cbuf
)->filename
, Feval
,
1448 !NILP (printflag
), Qnil
, read_function
);
1450 return unbind_to (count
, Qnil
);
1454 DEFUN ("read", Fread
, Sread
, 0, 1, 0,
1455 doc
: /* Read one Lisp expression as text from STREAM, return as Lisp object.
1456 If STREAM is nil, use the value of `standard-input' (which see).
1457 STREAM or the value of `standard-input' may be:
1458 a buffer (read from point and advance it)
1459 a marker (read from where it points and advance it)
1460 a function (call it with no arguments for each character,
1461 call it with a char as argument to push a char back)
1462 a string (takes text from string, starting at the beginning)
1463 t (read text line using minibuffer and use it, or read from
1464 standard input in batch mode). */)
1469 stream
= Vstandard_input
;
1470 if (EQ (stream
, Qt
))
1471 stream
= Qread_char
;
1472 if (EQ (stream
, Qread_char
))
1473 return Fread_minibuffer (build_string ("Lisp expression: "), Qnil
);
1475 return read_internal_start (stream
, Qnil
, Qnil
);
1478 DEFUN ("read-from-string", Fread_from_string
, Sread_from_string
, 1, 3, 0,
1479 doc
: /* Read one Lisp expression which is represented as text by STRING.
1480 Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
1481 START and END optionally delimit a substring of STRING from which to read;
1482 they default to 0 and (length STRING) respectively. */)
1483 (string
, start
, end
)
1484 Lisp_Object string
, start
, end
;
1487 CHECK_STRING (string
);
1488 /* read_internal_start sets read_from_string_index. */
1489 ret
= read_internal_start (string
, start
, end
);
1490 return Fcons (ret
, make_number (read_from_string_index
));
1493 /* Function to set up the global context we need in toplevel read
1496 read_internal_start (stream
, start
, end
)
1498 Lisp_Object start
; /* Only used when stream is a string. */
1499 Lisp_Object end
; /* Only used when stream is a string. */
1503 readchar_backlog
= -1;
1505 new_backquote_flag
= 0;
1506 read_objects
= Qnil
;
1507 if (EQ (Vread_with_symbol_positions
, Qt
)
1508 || EQ (Vread_with_symbol_positions
, stream
))
1509 Vread_symbol_positions_list
= Qnil
;
1511 if (STRINGP (stream
))
1513 int startval
, endval
;
1515 endval
= SCHARS (stream
);
1519 endval
= XINT (end
);
1520 if (endval
< 0 || endval
> SCHARS (stream
))
1521 args_out_of_range (stream
, end
);
1528 CHECK_NUMBER (start
);
1529 startval
= XINT (start
);
1530 if (startval
< 0 || startval
> endval
)
1531 args_out_of_range (stream
, start
);
1533 read_from_string_index
= startval
;
1534 read_from_string_index_byte
= string_char_to_byte (stream
, startval
);
1535 read_from_string_limit
= endval
;
1538 retval
= read0 (stream
);
1539 if (EQ (Vread_with_symbol_positions
, Qt
)
1540 || EQ (Vread_with_symbol_positions
, stream
))
1541 Vread_symbol_positions_list
= Fnreverse (Vread_symbol_positions_list
);
1545 /* Use this for recursive reads, in contexts where internal tokens
1550 Lisp_Object readcharfun
;
1552 register Lisp_Object val
;
1555 val
= read1 (readcharfun
, &c
, 0);
1557 Fsignal (Qinvalid_read_syntax
, Fcons (Fmake_string (make_number (1),
1564 static int read_buffer_size
;
1565 static char *read_buffer
;
1567 /* Read multibyte form and return it as a character. C is a first
1568 byte of multibyte form, and rest of them are read from
1572 read_multibyte (c
, readcharfun
)
1574 Lisp_Object readcharfun
;
1576 /* We need the actual character code of this multibyte
1578 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
1586 while ((c
= READCHAR
) >= 0xA0
1587 && len
< MAX_MULTIBYTE_LENGTH
)
1593 if (UNIBYTE_STR_AS_MULTIBYTE_P (str
, len
, bytes
))
1594 return STRING_CHAR (str
, len
);
1595 /* The byte sequence is not valid as multibyte. Unread all bytes
1596 but the first one, and return the first byte. */
1602 /* Read a \-escape sequence, assuming we already read the `\'.
1603 If the escape sequence forces unibyte, store 1 into *BYTEREP.
1604 If the escape sequence forces multibyte, store 2 into *BYTEREP.
1605 Otherwise store 0 into *BYTEREP. */
1608 read_escape (readcharfun
, stringp
, byterep
)
1609 Lisp_Object readcharfun
;
1613 register int c
= READCHAR
;
1620 end_of_file_error ();
1650 error ("Invalid escape character syntax");
1653 c
= read_escape (readcharfun
, 0, byterep
);
1654 return c
| meta_modifier
;
1659 error ("Invalid escape character syntax");
1662 c
= read_escape (readcharfun
, 0, byterep
);
1663 return c
| shift_modifier
;
1668 error ("Invalid escape character syntax");
1671 c
= read_escape (readcharfun
, 0, byterep
);
1672 return c
| hyper_modifier
;
1677 error ("Invalid escape character syntax");
1680 c
= read_escape (readcharfun
, 0, byterep
);
1681 return c
| alt_modifier
;
1686 error ("Invalid escape character syntax");
1689 c
= read_escape (readcharfun
, 0, byterep
);
1690 return c
| super_modifier
;
1695 error ("Invalid escape character syntax");
1699 c
= read_escape (readcharfun
, 0, byterep
);
1700 if ((c
& ~CHAR_MODIFIER_MASK
) == '?')
1701 return 0177 | (c
& CHAR_MODIFIER_MASK
);
1702 else if (! SINGLE_BYTE_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
1703 return c
| ctrl_modifier
;
1704 /* ASCII control chars are made from letters (both cases),
1705 as well as the non-letters within 0100...0137. */
1706 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
1707 return (c
& (037 | ~0177));
1708 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
1709 return (c
& (037 | ~0177));
1711 return c
| ctrl_modifier
;
1721 /* An octal escape, as in ANSI C. */
1723 register int i
= c
- '0';
1724 register int count
= 0;
1727 if ((c
= READCHAR
) >= '0' && c
<= '7')
1744 /* A hex escape, as in ANSI C. */
1750 if (c
>= '0' && c
<= '9')
1755 else if ((c
>= 'a' && c
<= 'f')
1756 || (c
>= 'A' && c
<= 'F'))
1759 if (c
>= 'a' && c
<= 'f')
1776 if (BASE_LEADING_CODE_P (c
))
1777 c
= read_multibyte (c
, readcharfun
);
1783 /* Read an integer in radix RADIX using READCHARFUN to read
1784 characters. RADIX must be in the interval [2..36]; if it isn't, a
1785 read error is signaled . Value is the integer read. Signals an
1786 error if encountering invalid read syntax or if RADIX is out of
1790 read_integer (readcharfun
, radix
)
1791 Lisp_Object readcharfun
;
1794 int ndigits
= 0, invalid_p
, c
, sign
= 0;
1795 EMACS_INT number
= 0;
1797 if (radix
< 2 || radix
> 36)
1801 number
= ndigits
= invalid_p
= 0;
1817 if (c
>= '0' && c
<= '9')
1819 else if (c
>= 'a' && c
<= 'z')
1820 digit
= c
- 'a' + 10;
1821 else if (c
>= 'A' && c
<= 'Z')
1822 digit
= c
- 'A' + 10;
1829 if (digit
< 0 || digit
>= radix
)
1832 number
= radix
* number
+ digit
;
1838 if (ndigits
== 0 || invalid_p
)
1841 sprintf (buf
, "integer, radix %d", radix
);
1842 Fsignal (Qinvalid_read_syntax
, Fcons (build_string (buf
), Qnil
));
1845 return make_number (sign
* number
);
1849 /* Convert unibyte text in read_buffer to multibyte.
1851 Initially, *P is a pointer after the end of the unibyte text, and
1852 the pointer *END points after the end of read_buffer.
1854 If read_buffer doesn't have enough room to hold the result
1855 of the conversion, reallocate it and adjust *P and *END.
1857 At the end, make *P point after the result of the conversion, and
1858 return in *NCHARS the number of characters in the converted
1862 to_multibyte (p
, end
, nchars
)
1868 parse_str_as_multibyte (read_buffer
, *p
- read_buffer
, &nbytes
, nchars
);
1869 if (read_buffer_size
< 2 * nbytes
)
1871 int offset
= *p
- read_buffer
;
1872 read_buffer_size
= 2 * max (read_buffer_size
, nbytes
);
1873 read_buffer
= (char *) xrealloc (read_buffer
, read_buffer_size
);
1874 *p
= read_buffer
+ offset
;
1875 *end
= read_buffer
+ read_buffer_size
;
1878 if (nbytes
!= *nchars
)
1879 nbytes
= str_as_multibyte (read_buffer
, read_buffer_size
,
1880 *p
- read_buffer
, nchars
);
1882 *p
= read_buffer
+ nbytes
;
1886 /* If the next token is ')' or ']' or '.', we store that character
1887 in *PCH and the return value is not interesting. Else, we store
1888 zero in *PCH and we read and return one lisp object.
1890 FIRST_IN_LIST is nonzero if this is the first element of a list. */
1893 read1 (readcharfun
, pch
, first_in_list
)
1894 register Lisp_Object readcharfun
;
1899 int uninterned_symbol
= 0;
1907 end_of_file_error ();
1912 return read_list (0, readcharfun
);
1915 return read_vector (readcharfun
, 0);
1932 tmp
= read_vector (readcharfun
, 0);
1933 if (XVECTOR (tmp
)->size
< CHAR_TABLE_STANDARD_SLOTS
1934 || XVECTOR (tmp
)->size
> CHAR_TABLE_STANDARD_SLOTS
+ 10)
1935 error ("Invalid size char-table");
1936 XSETCHAR_TABLE (tmp
, XCHAR_TABLE (tmp
));
1937 XCHAR_TABLE (tmp
)->top
= Qt
;
1946 tmp
= read_vector (readcharfun
, 0);
1947 if (XVECTOR (tmp
)->size
!= SUB_CHAR_TABLE_STANDARD_SLOTS
)
1948 error ("Invalid size char-table");
1949 XSETCHAR_TABLE (tmp
, XCHAR_TABLE (tmp
));
1950 XCHAR_TABLE (tmp
)->top
= Qnil
;
1953 Fsignal (Qinvalid_read_syntax
,
1954 Fcons (make_string ("#^^", 3), Qnil
));
1956 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#^", 2), Qnil
));
1961 length
= read1 (readcharfun
, pch
, first_in_list
);
1965 Lisp_Object tmp
, val
;
1966 int size_in_chars
= ((XFASTINT (length
) + BITS_PER_CHAR
- 1)
1970 tmp
= read1 (readcharfun
, pch
, first_in_list
);
1971 if (size_in_chars
!= SCHARS (tmp
)
1972 /* We used to print 1 char too many
1973 when the number of bits was a multiple of 8.
1974 Accept such input in case it came from an old version. */
1975 && ! (XFASTINT (length
)
1976 == (SCHARS (tmp
) - 1) * BITS_PER_CHAR
))
1977 Fsignal (Qinvalid_read_syntax
,
1978 Fcons (make_string ("#&...", 5), Qnil
));
1980 val
= Fmake_bool_vector (length
, Qnil
);
1981 bcopy (SDATA (tmp
), XBOOL_VECTOR (val
)->data
,
1983 /* Clear the extraneous bits in the last byte. */
1984 if (XINT (length
) != size_in_chars
* BITS_PER_CHAR
)
1985 XBOOL_VECTOR (val
)->data
[size_in_chars
- 1]
1986 &= (1 << (XINT (length
) % BITS_PER_CHAR
)) - 1;
1989 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#&...", 5),
1994 /* Accept compiled functions at read-time so that we don't have to
1995 build them using function calls. */
1997 tmp
= read_vector (readcharfun
, 1);
1998 return Fmake_byte_code (XVECTOR (tmp
)->size
,
1999 XVECTOR (tmp
)->contents
);
2004 struct gcpro gcpro1
;
2007 /* Read the string itself. */
2008 tmp
= read1 (readcharfun
, &ch
, 0);
2009 if (ch
!= 0 || !STRINGP (tmp
))
2010 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
2012 /* Read the intervals and their properties. */
2015 Lisp_Object beg
, end
, plist
;
2017 beg
= read1 (readcharfun
, &ch
, 0);
2022 end
= read1 (readcharfun
, &ch
, 0);
2024 plist
= read1 (readcharfun
, &ch
, 0);
2026 Fsignal (Qinvalid_read_syntax
,
2027 Fcons (build_string ("invalid string property list"),
2029 Fset_text_properties (beg
, end
, plist
, tmp
);
2035 /* #@NUMBER is used to skip NUMBER following characters.
2036 That's used in .elc files to skip over doc strings
2037 and function definitions. */
2042 /* Read a decimal integer. */
2043 while ((c
= READCHAR
) >= 0
2044 && c
>= '0' && c
<= '9')
2052 if (load_force_doc_strings
&& EQ (readcharfun
, Qget_file_char
))
2054 /* If we are supposed to force doc strings into core right now,
2055 record the last string that we skipped,
2056 and record where in the file it comes from. */
2058 /* But first exchange saved_doc_string
2059 with prev_saved_doc_string, so we save two strings. */
2061 char *temp
= saved_doc_string
;
2062 int temp_size
= saved_doc_string_size
;
2063 file_offset temp_pos
= saved_doc_string_position
;
2064 int temp_len
= saved_doc_string_length
;
2066 saved_doc_string
= prev_saved_doc_string
;
2067 saved_doc_string_size
= prev_saved_doc_string_size
;
2068 saved_doc_string_position
= prev_saved_doc_string_position
;
2069 saved_doc_string_length
= prev_saved_doc_string_length
;
2071 prev_saved_doc_string
= temp
;
2072 prev_saved_doc_string_size
= temp_size
;
2073 prev_saved_doc_string_position
= temp_pos
;
2074 prev_saved_doc_string_length
= temp_len
;
2077 if (saved_doc_string_size
== 0)
2079 saved_doc_string_size
= nskip
+ 100;
2080 saved_doc_string
= (char *) xmalloc (saved_doc_string_size
);
2082 if (nskip
> saved_doc_string_size
)
2084 saved_doc_string_size
= nskip
+ 100;
2085 saved_doc_string
= (char *) xrealloc (saved_doc_string
,
2086 saved_doc_string_size
);
2089 saved_doc_string_position
= file_tell (instream
);
2091 /* Copy that many characters into saved_doc_string. */
2092 for (i
= 0; i
< nskip
&& c
>= 0; i
++)
2093 saved_doc_string
[i
] = c
= READCHAR
;
2095 saved_doc_string_length
= i
;
2099 /* Skip that many characters. */
2100 for (i
= 0; i
< nskip
&& c
>= 0; i
++)
2108 /* #! appears at the beginning of an executable file.
2109 Skip the first line. */
2115 return Vload_file_name
;
2117 return Fcons (Qfunction
, Fcons (read0 (readcharfun
), Qnil
));
2118 /* #:foo is the uninterned symbol named foo. */
2121 uninterned_symbol
= 1;
2125 /* Reader forms that can reuse previously read objects. */
2126 if (c
>= '0' && c
<= '9')
2131 /* Read a non-negative integer. */
2132 while (c
>= '0' && c
<= '9')
2138 /* #n=object returns object, but associates it with n for #n#. */
2141 /* Make a placeholder for #n# to use temporarily */
2142 Lisp_Object placeholder
;
2145 placeholder
= Fcons(Qnil
, Qnil
);
2146 cell
= Fcons (make_number (n
), placeholder
);
2147 read_objects
= Fcons (cell
, read_objects
);
2149 /* Read the object itself. */
2150 tem
= read0 (readcharfun
);
2152 /* Now put it everywhere the placeholder was... */
2153 substitute_object_in_subtree (tem
, placeholder
);
2155 /* ...and #n# will use the real value from now on. */
2156 Fsetcdr (cell
, tem
);
2160 /* #n# returns a previously read object. */
2163 tem
= Fassq (make_number (n
), read_objects
);
2166 /* Fall through to error message. */
2168 else if (c
== 'r' || c
== 'R')
2169 return read_integer (readcharfun
, n
);
2171 /* Fall through to error message. */
2173 else if (c
== 'x' || c
== 'X')
2174 return read_integer (readcharfun
, 16);
2175 else if (c
== 'o' || c
== 'O')
2176 return read_integer (readcharfun
, 8);
2177 else if (c
== 'b' || c
== 'B')
2178 return read_integer (readcharfun
, 2);
2181 Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("#", 1), Qnil
));
2184 while ((c
= READCHAR
) >= 0 && c
!= '\n');
2189 return Fcons (Qquote
, Fcons (read0 (readcharfun
), Qnil
));
2199 new_backquote_flag
++;
2200 value
= read0 (readcharfun
);
2201 new_backquote_flag
--;
2203 return Fcons (Qbackquote
, Fcons (value
, Qnil
));
2207 if (new_backquote_flag
)
2209 Lisp_Object comma_type
= Qnil
;
2214 comma_type
= Qcomma_at
;
2216 comma_type
= Qcomma_dot
;
2219 if (ch
>= 0) UNREAD (ch
);
2220 comma_type
= Qcomma
;
2223 new_backquote_flag
--;
2224 value
= read0 (readcharfun
);
2225 new_backquote_flag
++;
2226 return Fcons (comma_type
, Fcons (value
, Qnil
));
2237 end_of_file_error ();
2240 c
= read_escape (readcharfun
, 0, &discard
);
2241 else if (BASE_LEADING_CODE_P (c
))
2242 c
= read_multibyte (c
, readcharfun
);
2244 return make_number (c
);
2249 char *p
= read_buffer
;
2250 char *end
= read_buffer
+ read_buffer_size
;
2252 /* 1 if we saw an escape sequence specifying
2253 a multibyte character, or a multibyte character. */
2254 int force_multibyte
= 0;
2255 /* 1 if we saw an escape sequence specifying
2256 a single-byte character. */
2257 int force_singlebyte
= 0;
2258 /* 1 if read_buffer contains multibyte text now. */
2259 int is_multibyte
= 0;
2263 while ((c
= READCHAR
) >= 0
2266 if (end
- p
< MAX_MULTIBYTE_LENGTH
)
2268 int offset
= p
- read_buffer
;
2269 read_buffer
= (char *) xrealloc (read_buffer
,
2270 read_buffer_size
*= 2);
2271 p
= read_buffer
+ offset
;
2272 end
= read_buffer
+ read_buffer_size
;
2279 c
= read_escape (readcharfun
, 1, &byterep
);
2281 /* C is -1 if \ newline has just been seen */
2284 if (p
== read_buffer
)
2290 force_singlebyte
= 1;
2291 else if (byterep
== 2)
2292 force_multibyte
= 1;
2295 /* A character that must be multibyte forces multibyte. */
2296 if (! SINGLE_BYTE_CHAR_P (c
& ~CHAR_MODIFIER_MASK
))
2297 force_multibyte
= 1;
2299 /* If we just discovered the need to be multibyte,
2300 convert the text accumulated thus far. */
2301 if (force_multibyte
&& ! is_multibyte
)
2304 to_multibyte (&p
, &end
, &nchars
);
2307 /* Allow `\C- ' and `\C-?'. */
2308 if (c
== (CHAR_CTL
| ' '))
2310 else if (c
== (CHAR_CTL
| '?'))
2315 /* Shift modifier is valid only with [A-Za-z]. */
2316 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
2318 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
2319 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
2323 /* Move the meta bit to the right place for a string. */
2324 c
= (c
& ~CHAR_META
) | 0x80;
2325 if (c
& CHAR_MODIFIER_MASK
)
2326 error ("Invalid modifier in string");
2329 p
+= CHAR_STRING (c
, p
);
2337 end_of_file_error ();
2339 /* If purifying, and string starts with \ newline,
2340 return zero instead. This is for doc strings
2341 that we are really going to find in etc/DOC.nn.nn */
2342 if (!NILP (Vpurify_flag
) && NILP (Vdoc_file_name
) && cancel
)
2343 return make_number (0);
2345 if (is_multibyte
|| force_singlebyte
)
2347 else if (load_convert_to_unibyte
)
2350 to_multibyte (&p
, &end
, &nchars
);
2351 if (p
- read_buffer
!= nchars
)
2353 string
= make_multibyte_string (read_buffer
, nchars
,
2355 return Fstring_make_unibyte (string
);
2357 /* We can make a unibyte string directly. */
2360 else if (EQ (readcharfun
, Qget_file_char
)
2361 || EQ (readcharfun
, Qlambda
))
2363 /* Nowadays, reading directly from a file is used only for
2364 compiled Emacs Lisp files, and those always use the
2365 Emacs internal encoding. Meanwhile, Qlambda is used
2366 for reading dynamic byte code (compiled with
2367 byte-compile-dynamic = t). So make the string multibyte
2368 if the string contains any multibyte sequences.
2369 (to_multibyte is a no-op if not.) */
2370 to_multibyte (&p
, &end
, &nchars
);
2371 is_multibyte
= (p
- read_buffer
) != nchars
;
2374 /* In all other cases, if we read these bytes as
2375 separate characters, treat them as separate characters now. */
2378 /* We want readchar_count to be the number of characters, not
2379 bytes. Hence we adjust for multibyte characters in the
2380 string. ... But it doesn't seem to be necessary, because
2381 READCHAR *does* read multibyte characters from buffers. */
2382 /* readchar_count -= (p - read_buffer) - nchars; */
2384 return make_pure_string (read_buffer
, nchars
, p
- read_buffer
,
2386 return make_specified_string (read_buffer
, nchars
, p
- read_buffer
,
2392 int next_char
= READCHAR
;
2395 if (next_char
<= 040
2396 || index ("\"'`,(", next_char
))
2402 /* Otherwise, we fall through! Note that the atom-reading loop
2403 below will now loop at least once, assuring that we will not
2404 try to UNREAD two characters in a row. */
2408 if (c
<= 040) goto retry
;
2410 char *p
= read_buffer
;
2414 char *end
= read_buffer
+ read_buffer_size
;
2417 && !(c
== '\"' || c
== '\'' || c
== ';'
2418 || c
== '(' || c
== ')'
2419 || c
== '[' || c
== ']' || c
== '#'))
2421 if (end
- p
< MAX_MULTIBYTE_LENGTH
)
2423 int offset
= p
- read_buffer
;
2424 read_buffer
= (char *) xrealloc (read_buffer
,
2425 read_buffer_size
*= 2);
2426 p
= read_buffer
+ offset
;
2427 end
= read_buffer
+ read_buffer_size
;
2434 end_of_file_error ();
2438 if (! SINGLE_BYTE_CHAR_P (c
))
2439 p
+= CHAR_STRING (c
, p
);
2448 int offset
= p
- read_buffer
;
2449 read_buffer
= (char *) xrealloc (read_buffer
,
2450 read_buffer_size
*= 2);
2451 p
= read_buffer
+ offset
;
2452 end
= read_buffer
+ read_buffer_size
;
2459 if (!quoted
&& !uninterned_symbol
)
2462 register Lisp_Object val
;
2464 if (*p1
== '+' || *p1
== '-') p1
++;
2465 /* Is it an integer? */
2468 while (p1
!= p
&& (c
= *p1
) >= '0' && c
<= '9') p1
++;
2469 /* Integers can have trailing decimal points. */
2470 if (p1
> read_buffer
&& p1
< p
&& *p1
== '.') p1
++;
2472 /* It is an integer. */
2476 if (sizeof (int) == sizeof (EMACS_INT
))
2477 XSETINT (val
, atoi (read_buffer
));
2478 else if (sizeof (long) == sizeof (EMACS_INT
))
2479 XSETINT (val
, atol (read_buffer
));
2485 if (isfloat_string (read_buffer
))
2487 /* Compute NaN and infinities using 0.0 in a variable,
2488 to cope with compilers that think they are smarter
2494 /* Negate the value ourselves. This treats 0, NaNs,
2495 and infinity properly on IEEE floating point hosts,
2496 and works around a common bug where atof ("-0.0")
2498 int negative
= read_buffer
[0] == '-';
2500 /* The only way p[-1] can be 'F' or 'N', after isfloat_string
2501 returns 1, is if the input ends in e+INF or e+NaN. */
2508 value
= zero
/ zero
;
2511 value
= atof (read_buffer
+ negative
);
2515 return make_float (negative
? - value
: value
);
2519 Lisp_Object result
= uninterned_symbol
? make_symbol (read_buffer
)
2520 : intern (read_buffer
);
2521 if (EQ (Vread_with_symbol_positions
, Qt
)
2522 || EQ (Vread_with_symbol_positions
, readcharfun
))
2523 Vread_symbol_positions_list
=
2524 /* Kind of a hack; this will probably fail if characters
2525 in the symbol name were escaped. Not really a big
2527 Fcons (Fcons (result
,
2528 make_number (readchar_count
2529 - XFASTINT (Flength (Fsymbol_name (result
))))),
2530 Vread_symbol_positions_list
);
2538 /* List of nodes we've seen during substitute_object_in_subtree. */
2539 static Lisp_Object seen_list
;
2542 substitute_object_in_subtree (object
, placeholder
)
2544 Lisp_Object placeholder
;
2546 Lisp_Object check_object
;
2548 /* We haven't seen any objects when we start. */
2551 /* Make all the substitutions. */
2553 = substitute_object_recurse (object
, placeholder
, object
);
2555 /* Clear seen_list because we're done with it. */
2558 /* The returned object here is expected to always eq the
2560 if (!EQ (check_object
, object
))
2561 error ("Unexpected mutation error in reader");
2564 /* Feval doesn't get called from here, so no gc protection is needed. */
2565 #define SUBSTITUTE(get_val, set_val) \
2567 Lisp_Object old_value = get_val; \
2568 Lisp_Object true_value \
2569 = substitute_object_recurse (object, placeholder,\
2572 if (!EQ (old_value, true_value)) \
2579 substitute_object_recurse (object
, placeholder
, subtree
)
2581 Lisp_Object placeholder
;
2582 Lisp_Object subtree
;
2584 /* If we find the placeholder, return the target object. */
2585 if (EQ (placeholder
, subtree
))
2588 /* If we've been to this node before, don't explore it again. */
2589 if (!EQ (Qnil
, Fmemq (subtree
, seen_list
)))
2592 /* If this node can be the entry point to a cycle, remember that
2593 we've seen it. It can only be such an entry point if it was made
2594 by #n=, which means that we can find it as a value in
2596 if (!EQ (Qnil
, Frassq (subtree
, read_objects
)))
2597 seen_list
= Fcons (subtree
, seen_list
);
2599 /* Recurse according to subtree's type.
2600 Every branch must return a Lisp_Object. */
2601 switch (XTYPE (subtree
))
2603 case Lisp_Vectorlike
:
2606 int length
= XINT (Flength(subtree
));
2607 for (i
= 0; i
< length
; i
++)
2609 Lisp_Object idx
= make_number (i
);
2610 SUBSTITUTE (Faref (subtree
, idx
),
2611 Faset (subtree
, idx
, true_value
));
2618 SUBSTITUTE (Fcar_safe (subtree
),
2619 Fsetcar (subtree
, true_value
));
2620 SUBSTITUTE (Fcdr_safe (subtree
),
2621 Fsetcdr (subtree
, true_value
));
2627 /* Check for text properties in each interval.
2628 substitute_in_interval contains part of the logic. */
2630 INTERVAL root_interval
= STRING_INTERVALS (subtree
);
2631 Lisp_Object arg
= Fcons (object
, placeholder
);
2633 traverse_intervals_noorder (root_interval
,
2634 &substitute_in_interval
, arg
);
2639 /* Other types don't recurse any further. */
2645 /* Helper function for substitute_object_recurse. */
2647 substitute_in_interval (interval
, arg
)
2651 Lisp_Object object
= Fcar (arg
);
2652 Lisp_Object placeholder
= Fcdr (arg
);
2654 SUBSTITUTE(interval
->plist
, interval
->plist
= true_value
);
2673 if (*cp
== '+' || *cp
== '-')
2676 if (*cp
>= '0' && *cp
<= '9')
2679 while (*cp
>= '0' && *cp
<= '9')
2687 if (*cp
>= '0' && *cp
<= '9')
2690 while (*cp
>= '0' && *cp
<= '9')
2693 if (*cp
== 'e' || *cp
== 'E')
2697 if (*cp
== '+' || *cp
== '-')
2701 if (*cp
>= '0' && *cp
<= '9')
2704 while (*cp
>= '0' && *cp
<= '9')
2707 else if (cp
== start
)
2709 else if (cp
[-1] == '+' && cp
[0] == 'I' && cp
[1] == 'N' && cp
[2] == 'F')
2714 else if (cp
[-1] == '+' && cp
[0] == 'N' && cp
[1] == 'a' && cp
[2] == 'N')
2720 return (((*cp
== 0) || (*cp
== ' ') || (*cp
== '\t') || (*cp
== '\n') || (*cp
== '\r') || (*cp
== '\f'))
2721 && (state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
)
2722 || state
== (DOT_CHAR
|TRAIL_INT
)
2723 || state
== (LEAD_INT
|E_CHAR
|EXP_INT
)
2724 || state
== (LEAD_INT
|DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)
2725 || state
== (DOT_CHAR
|TRAIL_INT
|E_CHAR
|EXP_INT
)));
2730 read_vector (readcharfun
, bytecodeflag
)
2731 Lisp_Object readcharfun
;
2736 register Lisp_Object
*ptr
;
2737 register Lisp_Object tem
, item
, vector
;
2738 register struct Lisp_Cons
*otem
;
2741 tem
= read_list (1, readcharfun
);
2742 len
= Flength (tem
);
2743 vector
= (read_pure
? make_pure_vector (XINT (len
)) : Fmake_vector (len
, Qnil
));
2745 size
= XVECTOR (vector
)->size
;
2746 ptr
= XVECTOR (vector
)->contents
;
2747 for (i
= 0; i
< size
; i
++)
2750 /* If `load-force-doc-strings' is t when reading a lazily-loaded
2751 bytecode object, the docstring containing the bytecode and
2752 constants values must be treated as unibyte and passed to
2753 Fread, to get the actual bytecode string and constants vector. */
2754 if (bytecodeflag
&& load_force_doc_strings
)
2756 if (i
== COMPILED_BYTECODE
)
2758 if (!STRINGP (item
))
2759 error ("invalid byte code");
2761 /* Delay handling the bytecode slot until we know whether
2762 it is lazily-loaded (we can tell by whether the
2763 constants slot is nil). */
2764 ptr
[COMPILED_CONSTANTS
] = item
;
2767 else if (i
== COMPILED_CONSTANTS
)
2769 Lisp_Object bytestr
= ptr
[COMPILED_CONSTANTS
];
2773 /* Coerce string to unibyte (like string-as-unibyte,
2774 but without generating extra garbage and
2775 guaranteeing no change in the contents). */
2776 STRING_SET_CHARS (bytestr
, SBYTES (bytestr
));
2777 STRING_SET_UNIBYTE (bytestr
);
2779 item
= Fread (bytestr
);
2781 error ("invalid byte code");
2783 otem
= XCONS (item
);
2784 bytestr
= XCAR (item
);
2789 /* Now handle the bytecode slot. */
2790 ptr
[COMPILED_BYTECODE
] = read_pure
? Fpurecopy (bytestr
) : bytestr
;
2793 ptr
[i
] = read_pure
? Fpurecopy (item
) : item
;
2801 /* FLAG = 1 means check for ] to terminate rather than ) and .
2802 FLAG = -1 means check for starting with defun
2803 and make structure pure. */
2806 read_list (flag
, readcharfun
)
2808 register Lisp_Object readcharfun
;
2810 /* -1 means check next element for defun,
2811 0 means don't check,
2812 1 means already checked and found defun. */
2813 int defunflag
= flag
< 0 ? -1 : 0;
2814 Lisp_Object val
, tail
;
2815 register Lisp_Object elt
, tem
;
2816 struct gcpro gcpro1
, gcpro2
;
2817 /* 0 is the normal case.
2818 1 means this list is a doc reference; replace it with the number 0.
2819 2 means this list is a doc reference; replace it with the doc string. */
2820 int doc_reference
= 0;
2822 /* Initialize this to 1 if we are reading a list. */
2823 int first_in_list
= flag
<= 0;
2832 elt
= read1 (readcharfun
, &ch
, first_in_list
);
2837 /* While building, if the list starts with #$, treat it specially. */
2838 if (EQ (elt
, Vload_file_name
)
2840 && !NILP (Vpurify_flag
))
2842 if (NILP (Vdoc_file_name
))
2843 /* We have not yet called Snarf-documentation, so assume
2844 this file is described in the DOC-MM.NN file
2845 and Snarf-documentation will fill in the right value later.
2846 For now, replace the whole list with 0. */
2849 /* We have already called Snarf-documentation, so make a relative
2850 file name for this file, so it can be found properly
2851 in the installed Lisp directory.
2852 We don't use Fexpand_file_name because that would make
2853 the directory absolute now. */
2854 elt
= concat2 (build_string ("../lisp/"),
2855 Ffile_name_nondirectory (elt
));
2857 else if (EQ (elt
, Vload_file_name
)
2859 && load_force_doc_strings
)
2868 Fsignal (Qinvalid_read_syntax
,
2869 Fcons (make_string (") or . in a vector", 18), Qnil
));
2877 XSETCDR (tail
, read0 (readcharfun
));
2879 val
= read0 (readcharfun
);
2880 read1 (readcharfun
, &ch
, 0);
2884 if (doc_reference
== 1)
2885 return make_number (0);
2886 if (doc_reference
== 2)
2888 /* Get a doc string from the file we are loading.
2889 If it's in saved_doc_string, get it from there. */
2890 int pos
= XINT (XCDR (val
));
2891 /* Position is negative for user variables. */
2892 if (pos
< 0) pos
= -pos
;
2893 if (pos
>= saved_doc_string_position
2894 && pos
< (saved_doc_string_position
2895 + saved_doc_string_length
))
2897 int start
= pos
- saved_doc_string_position
;
2900 /* Process quoting with ^A,
2901 and find the end of the string,
2902 which is marked with ^_ (037). */
2903 for (from
= start
, to
= start
;
2904 saved_doc_string
[from
] != 037;)
2906 int c
= saved_doc_string
[from
++];
2909 c
= saved_doc_string
[from
++];
2911 saved_doc_string
[to
++] = c
;
2913 saved_doc_string
[to
++] = 0;
2915 saved_doc_string
[to
++] = 037;
2918 saved_doc_string
[to
++] = c
;
2921 return make_string (saved_doc_string
+ start
,
2924 /* Look in prev_saved_doc_string the same way. */
2925 else if (pos
>= prev_saved_doc_string_position
2926 && pos
< (prev_saved_doc_string_position
2927 + prev_saved_doc_string_length
))
2929 int start
= pos
- prev_saved_doc_string_position
;
2932 /* Process quoting with ^A,
2933 and find the end of the string,
2934 which is marked with ^_ (037). */
2935 for (from
= start
, to
= start
;
2936 prev_saved_doc_string
[from
] != 037;)
2938 int c
= prev_saved_doc_string
[from
++];
2941 c
= prev_saved_doc_string
[from
++];
2943 prev_saved_doc_string
[to
++] = c
;
2945 prev_saved_doc_string
[to
++] = 0;
2947 prev_saved_doc_string
[to
++] = 037;
2950 prev_saved_doc_string
[to
++] = c
;
2953 return make_string (prev_saved_doc_string
+ start
,
2957 return get_doc_string (val
, 0, 0);
2962 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string (". in wrong context", 18), Qnil
));
2964 return Fsignal (Qinvalid_read_syntax
, Fcons (make_string ("] in a list", 11), Qnil
));
2966 tem
= (read_pure
&& flag
<= 0
2967 ? pure_cons (elt
, Qnil
)
2968 : Fcons (elt
, Qnil
));
2970 XSETCDR (tail
, tem
);
2975 defunflag
= EQ (elt
, Qdefun
);
2976 else if (defunflag
> 0)
2981 Lisp_Object Vobarray
;
2982 Lisp_Object initial_obarray
;
2984 /* oblookup stores the bucket number here, for the sake of Funintern. */
2986 int oblookup_last_bucket_number
;
2988 static int hash_string ();
2990 /* Get an error if OBARRAY is not an obarray.
2991 If it is one, return it. */
2994 check_obarray (obarray
)
2995 Lisp_Object obarray
;
2997 while (!VECTORP (obarray
) || XVECTOR (obarray
)->size
== 0)
2999 /* If Vobarray is now invalid, force it to be valid. */
3000 if (EQ (Vobarray
, obarray
)) Vobarray
= initial_obarray
;
3002 obarray
= wrong_type_argument (Qvectorp
, obarray
);
3007 /* Intern the C string STR: return a symbol with that name,
3008 interned in the current obarray. */
3015 int len
= strlen (str
);
3016 Lisp_Object obarray
;
3019 if (!VECTORP (obarray
) || XVECTOR (obarray
)->size
== 0)
3020 obarray
= check_obarray (obarray
);
3021 tem
= oblookup (obarray
, str
, len
, len
);
3024 return Fintern (make_string (str
, len
), obarray
);
3027 /* Create an uninterned symbol with name STR. */
3033 int len
= strlen (str
);
3035 return Fmake_symbol ((!NILP (Vpurify_flag
)
3036 ? make_pure_string (str
, len
, len
, 0)
3037 : make_string (str
, len
)));
3040 DEFUN ("intern", Fintern
, Sintern
, 1, 2, 0,
3041 doc
: /* Return the canonical symbol whose name is STRING.
3042 If there is none, one is created by this function and returned.
3043 A second optional argument specifies the obarray to use;
3044 it defaults to the value of `obarray'. */)
3046 Lisp_Object string
, obarray
;
3048 register Lisp_Object tem
, sym
, *ptr
;
3050 if (NILP (obarray
)) obarray
= Vobarray
;
3051 obarray
= check_obarray (obarray
);
3053 CHECK_STRING (string
);
3055 tem
= oblookup (obarray
, SDATA (string
),
3058 if (!INTEGERP (tem
))
3061 if (!NILP (Vpurify_flag
))
3062 string
= Fpurecopy (string
);
3063 sym
= Fmake_symbol (string
);
3065 if (EQ (obarray
, initial_obarray
))
3066 XSYMBOL (sym
)->interned
= SYMBOL_INTERNED_IN_INITIAL_OBARRAY
;
3068 XSYMBOL (sym
)->interned
= SYMBOL_INTERNED
;
3070 if ((SREF (string
, 0) == ':')
3071 && EQ (obarray
, initial_obarray
))
3073 XSYMBOL (sym
)->constant
= 1;
3074 XSYMBOL (sym
)->value
= sym
;
3077 ptr
= &XVECTOR (obarray
)->contents
[XINT (tem
)];
3079 XSYMBOL (sym
)->next
= XSYMBOL (*ptr
);
3081 XSYMBOL (sym
)->next
= 0;
3086 DEFUN ("intern-soft", Fintern_soft
, Sintern_soft
, 1, 2, 0,
3087 doc
: /* Return the canonical symbol named NAME, or nil if none exists.
3088 NAME may be a string or a symbol. If it is a symbol, that exact
3089 symbol is searched for.
3090 A second optional argument specifies the obarray to use;
3091 it defaults to the value of `obarray'. */)
3093 Lisp_Object name
, obarray
;
3095 register Lisp_Object tem
, string
;
3097 if (NILP (obarray
)) obarray
= Vobarray
;
3098 obarray
= check_obarray (obarray
);
3100 if (!SYMBOLP (name
))
3102 CHECK_STRING (name
);
3106 string
= SYMBOL_NAME (name
);
3108 tem
= oblookup (obarray
, SDATA (string
), SCHARS (string
), SBYTES (string
));
3109 if (INTEGERP (tem
) || (SYMBOLP (name
) && !EQ (name
, tem
)))
3115 DEFUN ("unintern", Funintern
, Sunintern
, 1, 2, 0,
3116 doc
: /* Delete the symbol named NAME, if any, from OBARRAY.
3117 The value is t if a symbol was found and deleted, nil otherwise.
3118 NAME may be a string or a symbol. If it is a symbol, that symbol
3119 is deleted, if it belongs to OBARRAY--no other symbol is deleted.
3120 OBARRAY defaults to the value of the variable `obarray'. */)
3122 Lisp_Object name
, obarray
;
3124 register Lisp_Object string
, tem
;
3127 if (NILP (obarray
)) obarray
= Vobarray
;
3128 obarray
= check_obarray (obarray
);
3131 string
= SYMBOL_NAME (name
);
3134 CHECK_STRING (name
);
3138 tem
= oblookup (obarray
, SDATA (string
),
3143 /* If arg was a symbol, don't delete anything but that symbol itself. */
3144 if (SYMBOLP (name
) && !EQ (name
, tem
))
3147 XSYMBOL (tem
)->interned
= SYMBOL_UNINTERNED
;
3148 XSYMBOL (tem
)->constant
= 0;
3149 XSYMBOL (tem
)->indirect_variable
= 0;
3151 hash
= oblookup_last_bucket_number
;
3153 if (EQ (XVECTOR (obarray
)->contents
[hash
], tem
))
3155 if (XSYMBOL (tem
)->next
)
3156 XSETSYMBOL (XVECTOR (obarray
)->contents
[hash
], XSYMBOL (tem
)->next
);
3158 XSETINT (XVECTOR (obarray
)->contents
[hash
], 0);
3162 Lisp_Object tail
, following
;
3164 for (tail
= XVECTOR (obarray
)->contents
[hash
];
3165 XSYMBOL (tail
)->next
;
3168 XSETSYMBOL (following
, XSYMBOL (tail
)->next
);
3169 if (EQ (following
, tem
))
3171 XSYMBOL (tail
)->next
= XSYMBOL (following
)->next
;
3180 /* Return the symbol in OBARRAY whose names matches the string
3181 of SIZE characters (SIZE_BYTE bytes) at PTR.
3182 If there is no such symbol in OBARRAY, return nil.
3184 Also store the bucket number in oblookup_last_bucket_number. */
3187 oblookup (obarray
, ptr
, size
, size_byte
)
3188 Lisp_Object obarray
;
3189 register const char *ptr
;
3190 int size
, size_byte
;
3194 register Lisp_Object tail
;
3195 Lisp_Object bucket
, tem
;
3197 if (!VECTORP (obarray
)
3198 || (obsize
= XVECTOR (obarray
)->size
) == 0)
3200 obarray
= check_obarray (obarray
);
3201 obsize
= XVECTOR (obarray
)->size
;
3203 /* This is sometimes needed in the middle of GC. */
3204 obsize
&= ~ARRAY_MARK_FLAG
;
3205 /* Combining next two lines breaks VMS C 2.3. */
3206 hash
= hash_string (ptr
, size_byte
);
3208 bucket
= XVECTOR (obarray
)->contents
[hash
];
3209 oblookup_last_bucket_number
= hash
;
3210 if (XFASTINT (bucket
) == 0)
3212 else if (!SYMBOLP (bucket
))
3213 error ("Bad data in guts of obarray"); /* Like CADR error message */
3215 for (tail
= bucket
; ; XSETSYMBOL (tail
, XSYMBOL (tail
)->next
))
3217 if (SBYTES (SYMBOL_NAME (tail
)) == size_byte
3218 && SCHARS (SYMBOL_NAME (tail
)) == size
3219 && !bcmp (SDATA (SYMBOL_NAME (tail
)), ptr
, size_byte
))
3221 else if (XSYMBOL (tail
)->next
== 0)
3224 XSETINT (tem
, hash
);
3229 hash_string (ptr
, len
)
3230 const unsigned char *ptr
;
3233 register const unsigned char *p
= ptr
;
3234 register const unsigned char *end
= p
+ len
;
3235 register unsigned char c
;
3236 register int hash
= 0;
3241 if (c
>= 0140) c
-= 40;
3242 hash
= ((hash
<<3) + (hash
>>28) + c
);
3244 return hash
& 07777777777;
3248 map_obarray (obarray
, fn
, arg
)
3249 Lisp_Object obarray
;
3250 void (*fn
) P_ ((Lisp_Object
, Lisp_Object
));
3254 register Lisp_Object tail
;
3255 CHECK_VECTOR (obarray
);
3256 for (i
= XVECTOR (obarray
)->size
- 1; i
>= 0; i
--)
3258 tail
= XVECTOR (obarray
)->contents
[i
];
3263 if (XSYMBOL (tail
)->next
== 0)
3265 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
3271 mapatoms_1 (sym
, function
)
3272 Lisp_Object sym
, function
;
3274 call1 (function
, sym
);
3277 DEFUN ("mapatoms", Fmapatoms
, Smapatoms
, 1, 2, 0,
3278 doc
: /* Call FUNCTION on every symbol in OBARRAY.
3279 OBARRAY defaults to the value of `obarray'. */)
3281 Lisp_Object function
, obarray
;
3283 if (NILP (obarray
)) obarray
= Vobarray
;
3284 obarray
= check_obarray (obarray
);
3286 map_obarray (obarray
, mapatoms_1
, function
);
3290 #define OBARRAY_SIZE 1511
3295 Lisp_Object oblength
;
3299 XSETFASTINT (oblength
, OBARRAY_SIZE
);
3301 Qnil
= Fmake_symbol (make_pure_string ("nil", 3, 3, 0));
3302 Vobarray
= Fmake_vector (oblength
, make_number (0));
3303 initial_obarray
= Vobarray
;
3304 staticpro (&initial_obarray
);
3305 /* Intern nil in the obarray */
3306 XSYMBOL (Qnil
)->interned
= SYMBOL_INTERNED_IN_INITIAL_OBARRAY
;
3307 XSYMBOL (Qnil
)->constant
= 1;
3309 /* These locals are to kludge around a pyramid compiler bug. */
3310 hash
= hash_string ("nil", 3);
3311 /* Separate statement here to avoid VAXC bug. */
3312 hash
%= OBARRAY_SIZE
;
3313 tem
= &XVECTOR (Vobarray
)->contents
[hash
];
3316 Qunbound
= Fmake_symbol (make_pure_string ("unbound", 7, 7, 0));
3317 XSYMBOL (Qnil
)->function
= Qunbound
;
3318 XSYMBOL (Qunbound
)->value
= Qunbound
;
3319 XSYMBOL (Qunbound
)->function
= Qunbound
;
3322 XSYMBOL (Qnil
)->value
= Qnil
;
3323 XSYMBOL (Qnil
)->plist
= Qnil
;
3324 XSYMBOL (Qt
)->value
= Qt
;
3325 XSYMBOL (Qt
)->constant
= 1;
3327 /* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
3330 Qvariable_documentation
= intern ("variable-documentation");
3331 staticpro (&Qvariable_documentation
);
3333 read_buffer_size
= 100 + MAX_MULTIBYTE_LENGTH
;
3334 read_buffer
= (char *) xmalloc (read_buffer_size
);
3339 struct Lisp_Subr
*sname
;
3342 sym
= intern (sname
->symbol_name
);
3343 XSETSUBR (XSYMBOL (sym
)->function
, sname
);
3346 #ifdef NOTDEF /* use fset in subr.el now */
3348 defalias (sname
, string
)
3349 struct Lisp_Subr
*sname
;
3353 sym
= intern (string
);
3354 XSETSUBR (XSYMBOL (sym
)->function
, sname
);
3358 /* Define an "integer variable"; a symbol whose value is forwarded
3359 to a C variable of type int. Sample call: */
3360 /* DEFVAR_INT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
3362 defvar_int (namestring
, address
)
3366 Lisp_Object sym
, val
;
3367 sym
= intern (namestring
);
3368 val
= allocate_misc ();
3369 XMISCTYPE (val
) = Lisp_Misc_Intfwd
;
3370 XINTFWD (val
)->intvar
= address
;
3371 SET_SYMBOL_VALUE (sym
, val
);
3374 /* Similar but define a variable whose value is t if address contains 1,
3375 nil if address contains 0 */
3377 defvar_bool (namestring
, address
)
3381 Lisp_Object sym
, val
;
3382 sym
= intern (namestring
);
3383 val
= allocate_misc ();
3384 XMISCTYPE (val
) = Lisp_Misc_Boolfwd
;
3385 XBOOLFWD (val
)->boolvar
= address
;
3386 SET_SYMBOL_VALUE (sym
, val
);
3387 Vbyte_boolean_vars
= Fcons (sym
, Vbyte_boolean_vars
);
3390 /* Similar but define a variable whose value is the Lisp Object stored
3391 at address. Two versions: with and without gc-marking of the C
3392 variable. The nopro version is used when that variable will be
3393 gc-marked for some other reason, since marking the same slot twice
3394 can cause trouble with strings. */
3396 defvar_lisp_nopro (namestring
, address
)
3398 Lisp_Object
*address
;
3400 Lisp_Object sym
, val
;
3401 sym
= intern (namestring
);
3402 val
= allocate_misc ();
3403 XMISCTYPE (val
) = Lisp_Misc_Objfwd
;
3404 XOBJFWD (val
)->objvar
= address
;
3405 SET_SYMBOL_VALUE (sym
, val
);
3409 defvar_lisp (namestring
, address
)
3411 Lisp_Object
*address
;
3413 defvar_lisp_nopro (namestring
, address
);
3414 staticpro (address
);
3417 /* Similar but define a variable whose value is the Lisp Object stored in
3418 the current buffer. address is the address of the slot in the buffer
3419 that is current now. */
3422 defvar_per_buffer (namestring
, address
, type
, doc
)
3424 Lisp_Object
*address
;
3428 Lisp_Object sym
, val
;
3430 extern struct buffer buffer_local_symbols
;
3432 sym
= intern (namestring
);
3433 val
= allocate_misc ();
3434 offset
= (char *)address
- (char *)current_buffer
;
3436 XMISCTYPE (val
) = Lisp_Misc_Buffer_Objfwd
;
3437 XBUFFER_OBJFWD (val
)->offset
= offset
;
3438 SET_SYMBOL_VALUE (sym
, val
);
3439 PER_BUFFER_SYMBOL (offset
) = sym
;
3440 PER_BUFFER_TYPE (offset
) = type
;
3442 if (PER_BUFFER_IDX (offset
) == 0)
3443 /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
3444 slot of buffer_local_flags */
3449 /* Similar but define a variable whose value is the Lisp Object stored
3450 at a particular offset in the current kboard object. */
3453 defvar_kboard (namestring
, offset
)
3457 Lisp_Object sym
, val
;
3458 sym
= intern (namestring
);
3459 val
= allocate_misc ();
3460 XMISCTYPE (val
) = Lisp_Misc_Kboard_Objfwd
;
3461 XKBOARD_OBJFWD (val
)->offset
= offset
;
3462 SET_SYMBOL_VALUE (sym
, val
);
3465 /* Record the value of load-path used at the start of dumping
3466 so we can see if the site changed it later during dumping. */
3467 static Lisp_Object dump_path
;
3473 int turn_off_warning
= 0;
3475 /* Compute the default load-path. */
3477 normal
= PATH_LOADSEARCH
;
3478 Vload_path
= decode_env_path (0, normal
);
3480 if (NILP (Vpurify_flag
))
3481 normal
= PATH_LOADSEARCH
;
3483 normal
= PATH_DUMPLOADSEARCH
;
3485 /* In a dumped Emacs, we normally have to reset the value of
3486 Vload_path from PATH_LOADSEARCH, since the value that was dumped
3487 uses ../lisp, instead of the path of the installed elisp
3488 libraries. However, if it appears that Vload_path was changed
3489 from the default before dumping, don't override that value. */
3492 if (! NILP (Fequal (dump_path
, Vload_path
)))
3494 Vload_path
= decode_env_path (0, normal
);
3495 if (!NILP (Vinstallation_directory
))
3497 Lisp_Object tem
, tem1
, sitelisp
;
3499 /* Remove site-lisp dirs from path temporarily and store
3500 them in sitelisp, then conc them on at the end so
3501 they're always first in path. */
3505 tem
= Fcar (Vload_path
);
3506 tem1
= Fstring_match (build_string ("site-lisp"),
3510 Vload_path
= Fcdr (Vload_path
);
3511 sitelisp
= Fcons (tem
, sitelisp
);
3517 /* Add to the path the lisp subdir of the
3518 installation dir, if it exists. */
3519 tem
= Fexpand_file_name (build_string ("lisp"),
3520 Vinstallation_directory
);
3521 tem1
= Ffile_exists_p (tem
);
3524 if (NILP (Fmember (tem
, Vload_path
)))
3526 turn_off_warning
= 1;
3527 Vload_path
= Fcons (tem
, Vload_path
);
3531 /* That dir doesn't exist, so add the build-time
3532 Lisp dirs instead. */
3533 Vload_path
= nconc2 (Vload_path
, dump_path
);
3535 /* Add leim under the installation dir, if it exists. */
3536 tem
= Fexpand_file_name (build_string ("leim"),
3537 Vinstallation_directory
);
3538 tem1
= Ffile_exists_p (tem
);
3541 if (NILP (Fmember (tem
, Vload_path
)))
3542 Vload_path
= Fcons (tem
, Vload_path
);
3545 /* Add site-list under the installation dir, if it exists. */
3546 tem
= Fexpand_file_name (build_string ("site-lisp"),
3547 Vinstallation_directory
);
3548 tem1
= Ffile_exists_p (tem
);
3551 if (NILP (Fmember (tem
, Vload_path
)))
3552 Vload_path
= Fcons (tem
, Vload_path
);
3555 /* If Emacs was not built in the source directory,
3556 and it is run from where it was built, add to load-path
3557 the lisp, leim and site-lisp dirs under that directory. */
3559 if (NILP (Fequal (Vinstallation_directory
, Vsource_directory
)))
3563 tem
= Fexpand_file_name (build_string ("src/Makefile"),
3564 Vinstallation_directory
);
3565 tem1
= Ffile_exists_p (tem
);
3567 /* Don't be fooled if they moved the entire source tree
3568 AFTER dumping Emacs. If the build directory is indeed
3569 different from the source dir, src/Makefile.in and
3570 src/Makefile will not be found together. */
3571 tem
= Fexpand_file_name (build_string ("src/Makefile.in"),
3572 Vinstallation_directory
);
3573 tem2
= Ffile_exists_p (tem
);
3574 if (!NILP (tem1
) && NILP (tem2
))
3576 tem
= Fexpand_file_name (build_string ("lisp"),
3579 if (NILP (Fmember (tem
, Vload_path
)))
3580 Vload_path
= Fcons (tem
, Vload_path
);
3582 tem
= Fexpand_file_name (build_string ("leim"),
3585 if (NILP (Fmember (tem
, Vload_path
)))
3586 Vload_path
= Fcons (tem
, Vload_path
);
3588 tem
= Fexpand_file_name (build_string ("site-lisp"),
3591 if (NILP (Fmember (tem
, Vload_path
)))
3592 Vload_path
= Fcons (tem
, Vload_path
);
3595 if (!NILP (sitelisp
))
3596 Vload_path
= nconc2 (Fnreverse (sitelisp
), Vload_path
);
3602 /* NORMAL refers to the lisp dir in the source directory. */
3603 /* We used to add ../lisp at the front here, but
3604 that caused trouble because it was copied from dump_path
3605 into Vload_path, aboe, when Vinstallation_directory was non-nil.
3606 It should be unnecessary. */
3607 Vload_path
= decode_env_path (0, normal
);
3608 dump_path
= Vload_path
;
3613 /* When Emacs is invoked over network shares on NT, PATH_LOADSEARCH is
3614 almost never correct, thereby causing a warning to be printed out that
3615 confuses users. Since PATH_LOADSEARCH is always overridden by the
3616 EMACSLOADPATH environment variable below, disable the warning on NT. */
3618 /* Warn if dirs in the *standard* path don't exist. */
3619 if (!turn_off_warning
)
3621 Lisp_Object path_tail
;
3623 for (path_tail
= Vload_path
;
3625 path_tail
= XCDR (path_tail
))
3627 Lisp_Object dirfile
;
3628 dirfile
= Fcar (path_tail
);
3629 if (STRINGP (dirfile
))
3631 dirfile
= Fdirectory_file_name (dirfile
);
3632 if (access (SDATA (dirfile
), 0) < 0)
3633 dir_warning ("Warning: Lisp directory `%s' does not exist.\n",
3638 #endif /* WINDOWSNT */
3640 /* If the EMACSLOADPATH environment variable is set, use its value.
3641 This doesn't apply if we're dumping. */
3643 if (NILP (Vpurify_flag
)
3644 && egetenv ("EMACSLOADPATH"))
3646 Vload_path
= decode_env_path ("EMACSLOADPATH", normal
);
3650 load_in_progress
= 0;
3651 Vload_file_name
= Qnil
;
3653 load_descriptor_list
= Qnil
;
3655 Vstandard_input
= Qt
;
3656 Vloads_in_progress
= Qnil
;
3659 /* Print a warning, using format string FORMAT, that directory DIRNAME
3660 does not exist. Print it on stderr and put it in *Message*. */
3663 dir_warning (format
, dirname
)
3665 Lisp_Object dirname
;
3668 = (char *) alloca (SCHARS (dirname
) + strlen (format
) + 5);
3670 fprintf (stderr
, format
, SDATA (dirname
));
3671 sprintf (buffer
, format
, SDATA (dirname
));
3672 /* Don't log the warning before we've initialized!! */
3674 message_dolog (buffer
, strlen (buffer
), 0, STRING_MULTIBYTE (dirname
));
3681 defsubr (&Sread_from_string
);
3683 defsubr (&Sintern_soft
);
3684 defsubr (&Sunintern
);
3686 defsubr (&Seval_buffer
);
3687 defsubr (&Seval_region
);
3688 defsubr (&Sread_char
);
3689 defsubr (&Sread_char_exclusive
);
3690 defsubr (&Sread_event
);
3691 defsubr (&Sget_file_char
);
3692 defsubr (&Smapatoms
);
3693 defsubr (&Slocate_file_internal
);
3695 DEFVAR_LISP ("obarray", &Vobarray
,
3696 doc
: /* Symbol table for use by `intern' and `read'.
3697 It is a vector whose length ought to be prime for best results.
3698 The vector's contents don't make sense if examined from Lisp programs;
3699 to find all the symbols in an obarray, use `mapatoms'. */);
3701 DEFVAR_LISP ("values", &Vvalues
,
3702 doc
: /* List of values of all expressions which were read, evaluated and printed.
3703 Order is reverse chronological. */);
3705 DEFVAR_LISP ("standard-input", &Vstandard_input
,
3706 doc
: /* Stream for read to get input from.
3707 See documentation of `read' for possible values. */);
3708 Vstandard_input
= Qt
;
3710 DEFVAR_LISP ("read-with-symbol-positions", &Vread_with_symbol_positions
,
3711 doc
: /* If non-nil, add position of read symbols to `read-symbol-positions-list'.
3713 If this variable is a buffer, then only forms read from that buffer
3714 will be added to `read-symbol-positions-list'.
3715 If this variable is t, then all read forms will be added.
3716 The effect of all other values other than nil are not currently
3717 defined, although they may be in the future.
3719 The positions are relative to the last call to `read' or
3720 `read-from-string'. It is probably a bad idea to set this variable at
3721 the toplevel; bind it instead. */);
3722 Vread_with_symbol_positions
= Qnil
;
3724 DEFVAR_LISP ("read-symbol-positions-list", &Vread_symbol_positions_list
,
3725 doc
: /* A list mapping read symbols to their positions.
3726 This variable is modified during calls to `read' or
3727 `read-from-string', but only when `read-with-symbol-positions' is
3730 Each element of the list looks like (SYMBOL . CHAR-POSITION), where
3731 CHAR-POSITION is an integer giving the offset of that occurrence of the
3732 symbol from the position where `read' or `read-from-string' started.
3734 Note that a symbol will appear multiple times in this list, if it was
3735 read multiple times. The list is in the same order as the symbols
3737 Vread_symbol_positions_list
= Qnil
;
3739 DEFVAR_LISP ("load-path", &Vload_path
,
3740 doc
: /* *List of directories to search for files to load.
3741 Each element is a string (directory name) or nil (try default directory).
3742 Initialized based on EMACSLOADPATH environment variable, if any,
3743 otherwise to default specified by file `epaths.h' when Emacs was built. */);
3745 DEFVAR_LISP ("load-suffixes", &Vload_suffixes
,
3746 doc
: /* *List of suffixes to try for files to load.
3747 This list should not include the empty string. */);
3748 Vload_suffixes
= Fcons (build_string (".elc"),
3749 Fcons (build_string (".el"), Qnil
));
3750 /* We don't use empty_string because it's not initialized yet. */
3751 default_suffixes
= Fcons (build_string (""), Qnil
);
3752 staticpro (&default_suffixes
);
3754 DEFVAR_BOOL ("load-in-progress", &load_in_progress
,
3755 doc
: /* Non-nil iff inside of `load'. */);
3757 DEFVAR_LISP ("after-load-alist", &Vafter_load_alist
,
3758 doc
: /* An alist of expressions to be evalled when particular files are loaded.
3759 Each element looks like (FILENAME FORMS...).
3760 When `load' is run and the file-name argument is FILENAME,
3761 the FORMS in the corresponding element are executed at the end of loading.
3763 FILENAME must match exactly! Normally FILENAME is the name of a library,
3764 with no directory specified, since that is how `load' is normally called.
3765 An error in FORMS does not undo the load,
3766 but does prevent execution of the rest of the FORMS.
3767 FILENAME can also be a symbol (a feature) and FORMS are then executed
3768 when the corresponding call to `provide' is made. */);
3769 Vafter_load_alist
= Qnil
;
3771 DEFVAR_LISP ("load-history", &Vload_history
,
3772 doc
: /* Alist mapping source file names to symbols and features.
3773 Each alist element is a list that starts with a file name,
3774 except for one element (optional) that starts with nil and describes
3775 definitions evaluated from buffers not visiting files.
3776 The remaining elements of each list are symbols defined as functions,
3777 and cons cells of the form `(provide . FEATURE)', `(require . FEATURE)',
3778 `(defvar . VARIABLE), and `(autoload . SYMBOL)'. */);
3779 Vload_history
= Qnil
;
3781 DEFVAR_LISP ("load-file-name", &Vload_file_name
,
3782 doc
: /* Full name of file being loaded by `load'. */);
3783 Vload_file_name
= Qnil
;
3785 DEFVAR_LISP ("user-init-file", &Vuser_init_file
,
3786 doc
: /* File name, including directory, of user's initialization file.
3787 If the file loaded had extension `.elc' and there was a corresponding `.el'
3788 file, this variable contains the name of the .el file, suitable for use
3789 by functions like `custom-save-all' which edit the init file. */);
3790 Vuser_init_file
= Qnil
;
3792 DEFVAR_LISP ("current-load-list", &Vcurrent_load_list
,
3793 doc
: /* Used for internal purposes by `load'. */);
3794 Vcurrent_load_list
= Qnil
;
3796 DEFVAR_LISP ("load-read-function", &Vload_read_function
,
3797 doc
: /* Function used by `load' and `eval-region' for reading expressions.
3798 The default is nil, which means use the function `read'. */);
3799 Vload_read_function
= Qnil
;
3801 DEFVAR_LISP ("load-source-file-function", &Vload_source_file_function
,
3802 doc
: /* Function called in `load' for loading an Emacs lisp source file.
3803 This function is for doing code conversion before reading the source file.
3804 If nil, loading is done without any code conversion.
3805 Arguments are FULLNAME, FILE, NOERROR, NOMESSAGE, where
3806 FULLNAME is the full name of FILE.
3807 See `load' for the meaning of the remaining arguments. */);
3808 Vload_source_file_function
= Qnil
;
3810 DEFVAR_BOOL ("load-force-doc-strings", &load_force_doc_strings
,
3811 doc
: /* Non-nil means `load' should force-load all dynamic doc strings.
3812 This is useful when the file being loaded is a temporary copy. */);
3813 load_force_doc_strings
= 0;
3815 DEFVAR_BOOL ("load-convert-to-unibyte", &load_convert_to_unibyte
,
3816 doc
: /* Non-nil means `read' converts strings to unibyte whenever possible.
3817 This is normally bound by `load' and `eval-buffer' to control `read',
3818 and is not meant for users to change. */);
3819 load_convert_to_unibyte
= 0;
3821 DEFVAR_LISP ("source-directory", &Vsource_directory
,
3822 doc
: /* Directory in which Emacs sources were found when Emacs was built.
3823 You cannot count on them to still be there! */);
3825 = Fexpand_file_name (build_string ("../"),
3826 Fcar (decode_env_path (0, PATH_DUMPLOADSEARCH
)));
3828 DEFVAR_LISP ("preloaded-file-list", &Vpreloaded_file_list
,
3829 doc
: /* List of files that were preloaded (when dumping Emacs). */);
3830 Vpreloaded_file_list
= Qnil
;
3832 DEFVAR_LISP ("byte-boolean-vars", &Vbyte_boolean_vars
,
3833 doc
: /* List of all DEFVAR_BOOL variables, used by the byte code optimizer. */);
3834 Vbyte_boolean_vars
= Qnil
;
3836 DEFVAR_BOOL ("load-dangerous-libraries", &load_dangerous_libraries
,
3837 doc
: /* Non-nil means load dangerous compiled Lisp files.
3838 Some versions of XEmacs use different byte codes than Emacs. These
3839 incompatible byte codes can make Emacs crash when it tries to execute
3841 load_dangerous_libraries
= 0;
3843 DEFVAR_LISP ("bytecomp-version-regexp", &Vbytecomp_version_regexp
,
3844 doc
: /* Regular expression matching safe to load compiled Lisp files.
3845 When Emacs loads a compiled Lisp file, it reads the first 512 bytes
3846 from the file, and matches them against this regular expression.
3847 When the regular expression matches, the file is considered to be safe
3848 to load. See also `load-dangerous-libraries'. */);
3849 Vbytecomp_version_regexp
3850 = build_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
3852 /* Vsource_directory was initialized in init_lread. */
3854 load_descriptor_list
= Qnil
;
3855 staticpro (&load_descriptor_list
);
3857 Qcurrent_load_list
= intern ("current-load-list");
3858 staticpro (&Qcurrent_load_list
);
3860 Qstandard_input
= intern ("standard-input");
3861 staticpro (&Qstandard_input
);
3863 Qread_char
= intern ("read-char");
3864 staticpro (&Qread_char
);
3866 Qget_file_char
= intern ("get-file-char");
3867 staticpro (&Qget_file_char
);
3869 Qbackquote
= intern ("`");
3870 staticpro (&Qbackquote
);
3871 Qcomma
= intern (",");
3872 staticpro (&Qcomma
);
3873 Qcomma_at
= intern (",@");
3874 staticpro (&Qcomma_at
);
3875 Qcomma_dot
= intern (",.");
3876 staticpro (&Qcomma_dot
);
3878 Qinhibit_file_name_operation
= intern ("inhibit-file-name-operation");
3879 staticpro (&Qinhibit_file_name_operation
);
3881 Qascii_character
= intern ("ascii-character");
3882 staticpro (&Qascii_character
);
3884 Qfunction
= intern ("function");
3885 staticpro (&Qfunction
);
3887 Qload
= intern ("load");
3890 Qload_file_name
= intern ("load-file-name");
3891 staticpro (&Qload_file_name
);
3893 staticpro (&dump_path
);
3895 staticpro (&read_objects
);
3896 read_objects
= Qnil
;
3897 staticpro (&seen_list
);
3899 Vloads_in_progress
= Qnil
;
3900 staticpro (&Vloads_in_progress
);