/* Lisp parsing and input streams.
- Copyright (C) 1985, 86, 87, 88, 89, 93, 94, 95, 97, 1998
+ Copyright (C) 1985, 86, 87, 88, 89, 93, 94, 95, 97, 98, 99, 2000, 2001
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <sys/file.h>
#include <errno.h>
#include "lisp.h"
-
-#ifndef standalone
+#include "intervals.h"
#include "buffer.h"
#include "charset.h"
-#include <paths.h>
+#include <epaths.h>
#include "commands.h"
#include "keyboard.h"
#include "termhooks.h"
-#endif
#ifdef lint
#include <sys/inode.h>
#define X_OK 01
#endif
-#ifdef LISP_FLOAT_TYPE
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#endif
-
#include <math.h>
-#endif /* LISP_FLOAT_TYPE */
#ifdef HAVE_SETLOCALE
#include <locale.h>
#define O_RDONLY 0
#endif
+#ifdef HAVE_FSEEKO
+#define file_offset off_t
+#define file_tell ftello
+#else
+#define file_offset long
+#define file_tell ftell
+#endif
+
+#ifndef USE_CRT_DLL
extern int errno;
+#endif
Lisp_Object Qread_char, Qget_file_char, Qstandard_input, Qcurrent_load_list;
Lisp_Object Qvariable_documentation, Vvalues, Vstandard_input, Vafter_load_alist;
/* Directory in which the sources were found. */
Lisp_Object Vsource_directory;
-/* Search path for files to be loaded. */
-Lisp_Object Vload_path;
+/* Search path and suffixes for files to be loaded. */
+Lisp_Object Vload_path, Vload_suffixes, default_suffixes;
+
+/* File name of user's init file. */
+Lisp_Object Vuser_init_file;
/* This is the user-visible association list that maps features to
lists of defs in their load files. */
compiled) instead of readevalloop. */
Lisp_Object Vload_source_file_function;
+/* List of all DEFVAR_BOOL variables. Used by the byte optimizer. */
+Lisp_Object Vbyte_boolean_vars;
+
/* List of descriptors now open for Fload. */
static Lisp_Object load_descriptor_list;
that `readchar' has already advanced over. */
static int readchar_backlog;
-/* This contains the last string skipped with #@, but only on some systems.
- On other systems we can't put the string here. */
+/* This contains the last string skipped with #@. */
static char *saved_doc_string;
/* Length of buffer allocated in saved_doc_string. */
static int saved_doc_string_size;
/* Length of actual data in saved_doc_string. */
static int saved_doc_string_length;
/* This is the file position that string came from. */
-static int saved_doc_string_position;
+static file_offset saved_doc_string_position;
+
+/* This contains the previous string skipped with #@.
+ We copy it from saved_doc_string when a new string
+ is put in saved_doc_string. */
+static char *prev_saved_doc_string;
+/* Length of buffer allocated in prev_saved_doc_string. */
+static int prev_saved_doc_string_size;
+/* Length of actual data in prev_saved_doc_string. */
+static int prev_saved_doc_string_length;
+/* This is the file position that string came from. */
+static file_offset prev_saved_doc_string_position;
/* Nonzero means inside a new-style backquote
with no surrounding parentheses.
Fread initializes this to zero, so we need not specbind it
or worry about what happens to it when there is an error. */
static int new_backquote_flag;
+
+/* A list of file names for files being loaded in Fload. Used to
+ check for recursive loads. */
+
+static Lisp_Object Vloads_in_progress;
+
+/* Limit of the depth of recursive loads. */
+
+Lisp_Object Vrecursive_load_depth_limit;
+
+/* Non-zero means load dangerous compiled Lisp files. */
+
+int load_dangerous_libraries;
+
+/* A regular expression used to detect files compiled with Emacs. */
+
+static Lisp_Object Vbytecomp_version_regexp;
+
+static void to_multibyte P_ ((char **, char **, int *));
+static void readevalloop P_ ((Lisp_Object, FILE*, Lisp_Object,
+ Lisp_Object (*) (), int,
+ Lisp_Object, Lisp_Object));
+static Lisp_Object load_unwind P_ ((Lisp_Object));
+static Lisp_Object load_descriptor_unwind P_ ((Lisp_Object));
+
\f
/* Handle unreading and rereading of characters.
Write READCHAR to read a character,
Lisp_Object readcharfun;
{
Lisp_Object tem;
- register int c, mpos;
+ register int c;
if (BUFFERP (readcharfun))
{
int pt_byte = BUF_PT_BYTE (inbuffer);
int orig_pt_byte = pt_byte;
+ if (readchar_backlog > 0)
+ /* We get the address of the byte just passed,
+ which is the last byte of the character.
+ The other bytes in this character are consecutive with it,
+ because the gap can't be in the middle of a character. */
+ return *(BUF_BYTE_ADDRESS (inbuffer, BUF_PT_BYTE (inbuffer) - 1)
+ - --readchar_backlog);
+
if (pt_byte >= BUF_ZV_BYTE (inbuffer))
return -1;
+ readchar_backlog = -1;
+
if (! NILP (inbuffer->enable_multibyte_characters))
{
+ /* Fetch the character code from the buffer. */
unsigned char *p = BUF_BYTE_ADDRESS (inbuffer, pt_byte);
BUF_INC_POS (inbuffer, pt_byte);
c = STRING_CHAR (p, pt_byte - orig_pt_byte);
int bytepos = marker_byte_position (readcharfun);
int orig_bytepos = bytepos;
+ if (readchar_backlog > 0)
+ /* We get the address of the byte just passed,
+ which is the last byte of the character.
+ The other bytes in this character are consecutive with it,
+ because the gap can't be in the middle of a character. */
+ return *(BUF_BYTE_ADDRESS (inbuffer, XMARKER (readcharfun)->bytepos - 1)
+ - --readchar_backlog);
+
if (bytepos >= BUF_ZV_BYTE (inbuffer))
return -1;
+ readchar_backlog = -1;
+
if (! NILP (inbuffer->enable_multibyte_characters))
{
+ /* Fetch the character code from the buffer. */
unsigned char *p = BUF_BYTE_ADDRESS (inbuffer, bytepos);
BUF_INC_POS (inbuffer, bytepos);
c = STRING_CHAR (p, bytepos - orig_bytepos);
return c;
}
+
+ if (EQ (readcharfun, Qlambda))
+ return read_bytecode_char (0);
+
if (EQ (readcharfun, Qget_file_char))
{
c = getc (instream);
{
if (read_from_string_index >= read_from_string_limit)
c = -1;
- else if (STRING_MULTIBYTE (readcharfun))
+ else
FETCH_STRING_CHAR_ADVANCE (c, readcharfun,
read_from_string_index,
read_from_string_index_byte);
- else
- c = XSTRING (readcharfun)->data[read_from_string_index++];
return c;
}
struct buffer *b = XBUFFER (readcharfun);
int bytepos = BUF_PT_BYTE (b);
- BUF_PT (b)--;
- if (! NILP (b->enable_multibyte_characters))
- BUF_DEC_POS (b, bytepos);
+ if (readchar_backlog >= 0)
+ readchar_backlog++;
else
- bytepos--;
+ {
+ BUF_PT (b)--;
+ if (! NILP (b->enable_multibyte_characters))
+ BUF_DEC_POS (b, bytepos);
+ else
+ bytepos--;
- BUF_PT_BYTE (b) = bytepos;
+ BUF_PT_BYTE (b) = bytepos;
+ }
}
else if (MARKERP (readcharfun))
{
struct buffer *b = XMARKER (readcharfun)->buffer;
int bytepos = XMARKER (readcharfun)->bytepos;
- XMARKER (readcharfun)->charpos--;
- if (! NILP (b->enable_multibyte_characters))
- BUF_DEC_POS (b, bytepos);
+ if (readchar_backlog >= 0)
+ readchar_backlog++;
else
- bytepos--;
+ {
+ XMARKER (readcharfun)->charpos--;
+ if (! NILP (b->enable_multibyte_characters))
+ BUF_DEC_POS (b, bytepos);
+ else
+ bytepos--;
- XMARKER (readcharfun)->bytepos = bytepos;
+ XMARKER (readcharfun)->bytepos = bytepos;
+ }
}
else if (STRINGP (readcharfun))
{
read_from_string_index_byte
= string_char_to_byte (readcharfun, read_from_string_index);
}
+ else if (EQ (readcharfun, Qlambda))
+ read_bytecode_char (1);
else if (EQ (readcharfun, Qget_file_char))
ungetc (c, instream);
else
static Lisp_Object read0 (), read1 (), read_list (), read_vector ();
static int read_multibyte ();
+static Lisp_Object substitute_object_recurse ();
+static void substitute_object_in_subtree (), substitute_in_interval ();
+
\f
/* Get a character from the tty. */
If ERROR_NONASCII is non-zero, we signal an error if the input we
get isn't an ASCII character with modifiers. If it's zero but
ASCII_REQUIRED is non-zero, we just re-read until we get an ASCII
- character. */
+ character.
+
+ If INPUT_METHOD is nonzero, we invoke the current input method
+ if the character warrants that. */
Lisp_Object
-read_filtered_event (no_switch_frame, ascii_required, error_nonascii)
- int no_switch_frame, ascii_required, error_nonascii;
+read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
+ input_method)
+ int no_switch_frame, ascii_required, error_nonascii, input_method;
{
-#ifdef standalone
- return make_number (getchar ());
-#else
register Lisp_Object val, delayed_switch_frame;
+#ifdef HAVE_WINDOW_SYSTEM
+ if (display_hourglass_p)
+ cancel_hourglass ();
+#endif
+
delayed_switch_frame = Qnil;
/* Read until we get an acceptable event. */
retry:
- val = read_char (0, 0, 0, Qnil, 0);
+ val = read_char (0, 0, 0,
+ (input_method ? Qnil : Qt),
+ 0);
if (BUFFERP (val))
goto retry;
/* Convert certain symbols to their ASCII equivalents. */
if (SYMBOLP (val))
{
- Lisp_Object tem, tem1, tem2;
+ Lisp_Object tem, tem1;
tem = Fget (val, Qevent_symbol_element_mask);
if (!NILP (tem))
{
if (! NILP (delayed_switch_frame))
unread_switch_frame = delayed_switch_frame;
- return val;
+#ifdef HAVE_WINDOW_SYSTEM
+ if (display_hourglass_p)
+ start_hourglass ();
#endif
+ return val;
}
-DEFUN ("read-char", Fread_char, Sread_char, 0, 0, 0,
- "Read a character from the command input (keyboard or macro).\n\
-It is returned as a number.\n\
-If the user generates an event which is not a character (i.e. a mouse\n\
-click or function key event), `read-char' signals an error. As an\n\
-exception, switch-frame events are put off until non-ASCII events can\n\
-be read.\n\
-If you want to read non-character events, or ignore them, call\n\
-`read-event' or `read-char-exclusive' instead.")
- ()
+DEFUN ("read-char", Fread_char, Sread_char, 0, 2, 0,
+ doc: /* Read a character from the command input (keyboard or macro).
+It is returned as a number.
+If the user generates an event which is not a character (i.e. a mouse
+click or function key event), `read-char' signals an error. As an
+exception, switch-frame events are put off until non-ASCII events can
+be read.
+If you want to read non-character events, or ignore them, call
+`read-event' or `read-char-exclusive' instead.
+
+If the optional argument PROMPT is non-nil, display that as a prompt.
+If the optional argument INHERIT-INPUT-METHOD is non-nil and some
+input method is turned on in the current buffer, that input method
+is used for reading a character. */)
+ (prompt, inherit_input_method)
+ Lisp_Object prompt, inherit_input_method;
{
- return read_filtered_event (1, 1, 1);
+ if (! NILP (prompt))
+ message_with_string ("%s", prompt, 0);
+ return read_filtered_event (1, 1, 1, ! NILP (inherit_input_method));
}
-DEFUN ("read-event", Fread_event, Sread_event, 0, 0, 0,
- "Read an event object from the input stream.")
- ()
+DEFUN ("read-event", Fread_event, Sread_event, 0, 2, 0,
+ doc: /* Read an event object from the input stream.
+If the optional argument PROMPT is non-nil, display that as a prompt.
+If the optional argument INHERIT-INPUT-METHOD is non-nil and some
+input method is turned on in the current buffer, that input method
+is used for reading a character. */)
+ (prompt, inherit_input_method)
+ Lisp_Object prompt, inherit_input_method;
{
- return read_filtered_event (0, 0, 0);
+ if (! NILP (prompt))
+ message_with_string ("%s", prompt, 0);
+ return read_filtered_event (0, 0, 0, ! NILP (inherit_input_method));
}
-DEFUN ("read-char-exclusive", Fread_char_exclusive, Sread_char_exclusive, 0, 0, 0,
- "Read a character from the command input (keyboard or macro).\n\
-It is returned as a number. Non-character events are ignored.")
- ()
+DEFUN ("read-char-exclusive", Fread_char_exclusive, Sread_char_exclusive, 0, 2, 0,
+ doc: /* Read a character from the command input (keyboard or macro).
+It is returned as a number. Non-character events are ignored.
+
+If the optional argument PROMPT is non-nil, display that as a prompt.
+If the optional argument INHERIT-INPUT-METHOD is non-nil and some
+input method is turned on in the current buffer, that input method
+is used for reading a character. */)
+ (prompt, inherit_input_method)
+ Lisp_Object prompt, inherit_input_method;
{
- return read_filtered_event (1, 1, 0);
+ if (! NILP (prompt))
+ message_with_string ("%s", prompt, 0);
+ return read_filtered_event (1, 1, 0, ! NILP (inherit_input_method));
}
DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
- "Don't use this yourself.")
- ()
+ doc: /* Don't use this yourself. */)
+ ()
{
register Lisp_Object val;
XSETINT (val, getc (instream));
return val;
}
+
+
\f
-static void readevalloop ();
-static Lisp_Object load_unwind ();
-static Lisp_Object load_descriptor_unwind ();
+/* Value is non-zero if the file asswociated with file descriptor FD
+ is a compiled Lisp file that's safe to load. Only files compiled
+ with Emacs are safe to load. Files compiled with XEmacs can lead
+ to a crash in Fbyte_code because of an incompatible change in the
+ byte compiler. */
+
+static int
+safe_to_load_p (fd)
+ int fd;
+{
+ char buf[512];
+ int nbytes, i;
+ int safe_p = 1;
+
+ /* Read the first few bytes from the file, and look for a line
+ specifying the byte compiler version used. */
+ nbytes = emacs_read (fd, buf, sizeof buf - 1);
+ if (nbytes > 0)
+ {
+ buf[nbytes] = '\0';
+
+ /* Skip to the next newline, skipping over the initial `ELC'
+ with NUL bytes following it. */
+ for (i = 0; i < nbytes && buf[i] != '\n'; ++i)
+ ;
+
+ if (i < nbytes
+ && fast_c_string_match_ignore_case (Vbytecomp_version_regexp,
+ buf + i) < 0)
+ safe_p = 0;
+ }
+
+ lseek (fd, 0, SEEK_SET);
+ return safe_p;
+}
+
+
+/* Callback for record_unwind_protect. Restore the old load list OLD,
+ after loading a file successfully. */
+
+static Lisp_Object
+record_load_unwind (old)
+ Lisp_Object old;
+{
+ return Vloads_in_progress = old;
+}
+
DEFUN ("load", Fload, Sload, 1, 5, 0,
- "Execute a file of Lisp code named FILE.\n\
-First try FILE with `.elc' appended, then try with `.el',\n\
- then try FILE unmodified.\n\
-This function searches the directories in `load-path'.\n\
-If optional second arg NOERROR is non-nil,\n\
- report no error if FILE doesn't exist.\n\
-Print messages at start and end of loading unless\n\
- optional third arg NOMESSAGE is non-nil.\n\
-If optional fourth arg NOSUFFIX is non-nil, don't try adding\n\
- suffixes `.elc' or `.el' to the specified name FILE.\n\
-If optional fifth arg MUST-SUFFIX is non-nil, insist on\n\
- the suffix `.elc' or `.el'; don't accept just FILE unless\n\
- it ends in one of those suffixes or includes a directory name.\n\
-Return t if file exists.")
- (file, noerror, nomessage, nosuffix, must_suffix)
+ doc: /* Execute a file of Lisp code named FILE.
+First try FILE with `.elc' appended, then try with `.el',
+ then try FILE unmodified. Environment variable references in FILE
+ are replaced with their values by calling `substitute-in-file-name'.
+This function searches the directories in `load-path'.
+If optional second arg NOERROR is non-nil,
+ report no error if FILE doesn't exist.
+Print messages at start and end of loading unless
+ optional third arg NOMESSAGE is non-nil.
+If optional fourth arg NOSUFFIX is non-nil, don't try adding
+ suffixes `.elc' or `.el' to the specified name FILE.
+If optional fifth arg MUST-SUFFIX is non-nil, insist on
+ the suffix `.elc' or `.el'; don't accept just FILE unless
+ it ends in one of those suffixes or includes a directory name.
+Return t if file exists. */)
+ (file, noerror, nomessage, nosuffix, must_suffix)
Lisp_Object file, noerror, nomessage, nosuffix, must_suffix;
{
register FILE *stream;
/* 1 means we are loading a compiled file. */
int compiled = 0;
Lisp_Object handler;
+ int safe_p = 1;
char *fmode = "r";
#ifdef DOS_NT
fmode = "rt";
#endif /* DOS_NT */
- CHECK_STRING (file, 0);
+ CHECK_STRING (file);
/* If file name is magic, call the handler. */
- handler = Ffind_file_name_handler (file, Qload);
- if (!NILP (handler))
- return call5 (handler, Qload, file, noerror, nomessage, nosuffix);
+ /* This shouldn't be necessary any more now that `openp' handles it right.
+ handler = Ffind_file_name_handler (file, Qload);
+ if (!NILP (handler))
+ return call5 (handler, Qload, file, noerror, nomessage, nosuffix); */
/* Do this after the handler to avoid
the need to gcpro noerror, nomessage and nosuffix.
- (Below here, we care only whether they are nil or not.) */
+ (Below here, we care only whether they are nil or not.)
+ The presence of this call is the result of a historical accident:
+ it used to be in every file-operations and when it got removed
+ everywhere, it accidentally stayed here. Since then, enough people
+ supposedly have things like (load "$PROJECT/foo.el") in their .emacs
+ that it seemed risky to remove. */
file = Fsubstitute_in_file_name (file);
/* Avoid weird lossage with null string as arg,
since it would try to load a directory as a Lisp file */
if (XSTRING (file)->size > 0)
{
- int size = XSTRING (file)->size;
+ int size = STRING_BYTES (XSTRING (file));
+ Lisp_Object tmp[2];
GCPRO1 (file);
}
fd = openp (Vload_path, file,
- (!NILP (nosuffix) ? ""
- : ! NILP (must_suffix) ? ".elc:.el"
- : ".elc:.el:"),
+ (!NILP (nosuffix) ? Qnil
+ : !NILP (must_suffix) ? Vload_suffixes
+ : Fappend (2, (tmp[0] = Vload_suffixes,
+ tmp[1] = default_suffixes,
+ tmp))),
&found, 0);
UNGCPRO;
}
- if (fd < 0)
+ if (fd == -1)
{
if (NILP (noerror))
while (1)
return Qnil;
}
- /* If FD is 0, that means openp found a remote file. */
- if (fd == 0)
+ /* Tell startup.el whether or not we found the user's init file. */
+ if (EQ (Qt, Vuser_init_file))
+ Vuser_init_file = found;
+
+ /* If FD is -2, that means openp found a magic file. */
+ if (fd == -2)
{
- handler = Ffind_file_name_handler (found, Qload);
- return call5 (handler, Qload, found, noerror, nomessage, Qt);
+ if (NILP (Fequal (found, file)))
+ /* If FOUND is a different file name from FILE,
+ find its handler even if we have already inhibited
+ the `load' operation on FILE. */
+ handler = Ffind_file_name_handler (found, Qt);
+ else
+ handler = Ffind_file_name_handler (found, Qload);
+ if (! NILP (handler))
+ return call5 (handler, Qload, found, noerror, nomessage, Qt);
}
- if (!bcmp (&(XSTRING (found)->data[XSTRING (found)->size - 4]),
+ /* Check if we're stuck in a recursive load cycle.
+
+ 2000-09-21: It's not possible to just check for the file loaded
+ being a member of Vloads_in_progress. This fails because of the
+ way the byte compiler currently works; `provide's are not
+ evaluted, see font-lock.el/jit-lock.el as an example. This
+ leads to a certain amount of ``normal'' recursion.
+
+ Also, just loading a file recursively is not always an error in
+ the general case; the second load may do something different. */
+ if (INTEGERP (Vrecursive_load_depth_limit)
+ && XINT (Vrecursive_load_depth_limit) > 0)
+ {
+ Lisp_Object len = Flength (Vloads_in_progress);
+ if (XFASTINT (len) > XFASTINT (Vrecursive_load_depth_limit))
+ Fsignal (Qerror, Fcons (build_string ("Recursive load suspected"),
+ Fcons (found, Vloads_in_progress)));
+ record_unwind_protect (record_load_unwind, Vloads_in_progress);
+ Vloads_in_progress = Fcons (found, Vloads_in_progress);
+ }
+
+ if (!bcmp (&(XSTRING (found)->data[STRING_BYTES (XSTRING (found)) - 4]),
".elc", 4))
+ /* Load .elc files directly, but not when they are
+ remote and have no handler! */
{
- struct stat s1, s2;
- int result;
+ if (fd != -2)
+ {
+ struct stat s1, s2;
+ int result;
+
+ if (!safe_to_load_p (fd))
+ {
+ safe_p = 0;
+ if (!load_dangerous_libraries)
+ error ("File `%s' was not compiled in Emacs",
+ XSTRING (found)->data);
+ else if (!NILP (nomessage))
+ message_with_string ("File `%s' not compiled in Emacs", found, 1);
+ }
- compiled = 1;
+ compiled = 1;
#ifdef DOS_NT
- fmode = "rb";
+ fmode = "rb";
#endif /* DOS_NT */
- stat ((char *)XSTRING (found)->data, &s1);
- XSTRING (found)->data[XSTRING (found)->size - 1] = 0;
- result = stat ((char *)XSTRING (found)->data, &s2);
- if (result >= 0 && (unsigned) s1.st_mtime < (unsigned) s2.st_mtime)
- {
- /* Make the progress messages mention that source is newer. */
- newer = 1;
+ stat ((char *)XSTRING (found)->data, &s1);
+ XSTRING (found)->data[STRING_BYTES (XSTRING (found)) - 1] = 0;
+ result = stat ((char *)XSTRING (found)->data, &s2);
+ if (result >= 0 && (unsigned) s1.st_mtime < (unsigned) s2.st_mtime)
+ {
+ /* Make the progress messages mention that source is newer. */
+ newer = 1;
- /* If we won't print another message, mention this anyway. */
- if (! NILP (nomessage))
- message_with_string ("Source file `%s' newer than byte-compiled file",
- found, 1);
+ /* If we won't print another message, mention this anyway. */
+ if (! NILP (nomessage))
+ message_with_string ("Source file `%s' newer than byte-compiled file",
+ found, 1);
+ }
+ XSTRING (found)->data[STRING_BYTES (XSTRING (found)) - 1] = 'c';
}
- XSTRING (found)->data[XSTRING (found)->size - 1] = 'c';
}
else
{
/* We are loading a source file (*.el). */
if (!NILP (Vload_source_file_function))
{
- close (fd);
- return call4 (Vload_source_file_function, found, file,
- NILP (noerror) ? Qnil : Qt,
- NILP (nomessage) ? Qnil : Qt);
+ Lisp_Object val;
+
+ if (fd >= 0)
+ emacs_close (fd);
+ val = call4 (Vload_source_file_function, found, file,
+ NILP (noerror) ? Qnil : Qt,
+ NILP (nomessage) ? Qnil : Qt);
+ return unbind_to (count, val);
}
}
#ifdef WINDOWSNT
- close (fd);
+ emacs_close (fd);
stream = fopen ((char *) XSTRING (found)->data, fmode);
#else /* not WINDOWSNT */
stream = fdopen (fd, fmode);
#endif /* not WINDOWSNT */
if (stream == 0)
{
- close (fd);
+ emacs_close (fd);
error ("Failure to create stdio stream for %s", XSTRING (file)->data);
}
if (NILP (nomessage))
{
- if (!compiled)
+ if (!safe_p)
+ message_with_string ("Loading %s (compiled; note unsafe, not compiled in Emacs)...",
+ file, 1);
+ else if (!compiled)
message_with_string ("Loading %s (source)...", file, 1);
else if (newer)
message_with_string ("Loading %s (compiled; note, source file is newer)...",
GCPRO1 (file);
lispstream = Fcons (Qnil, Qnil);
- XSETFASTINT (XCONS (lispstream)->car, (EMACS_UINT)stream >> 16);
- XSETFASTINT (XCONS (lispstream)->cdr, (EMACS_UINT)stream & 0xffff);
+ XSETCARFASTINT (lispstream, (EMACS_UINT)stream >> 16);
+ XSETCDRFASTINT (lispstream, (EMACS_UINT)stream & 0xffff);
record_unwind_protect (load_unwind, lispstream);
record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
specbind (Qload_file_name, found);
load_descriptor_list
= Fcons (make_number (fileno (stream)), load_descriptor_list);
load_in_progress++;
- readevalloop (Qget_file_char, stream, file, Feval, 0, Qnil);
+ readevalloop (Qget_file_char, stream, file, Feval, 0, Qnil, Qnil);
unbind_to (count, Qnil);
/* Run any load-hooks for this file. */
saved_doc_string = 0;
saved_doc_string_size = 0;
+ if (prev_saved_doc_string)
+ xfree (prev_saved_doc_string);
+ prev_saved_doc_string = 0;
+ prev_saved_doc_string_size = 0;
+
if (!noninteractive && NILP (nomessage))
{
- if (!compiled)
+ if (!safe_p)
+ message_with_string ("Loading %s (compiled; note unsafe, not compiled in Emacs)...done",
+ file, 1);
+ else if (!compiled)
message_with_string ("Loading %s (source)...done", file, 1);
else if (newer)
message_with_string ("Loading %s (compiled; note, source file is newer)...done",
else /* The typical case; compiled file newer than source file. */
message_with_string ("Loading %s...done", file, 1);
}
+
return Qt;
}
load_unwind (stream) /* used as unwind-protect function in load */
Lisp_Object stream;
{
- fclose ((FILE *) (XFASTINT (XCONS (stream)->car) << 16
- | XFASTINT (XCONS (stream)->cdr)));
+ fclose ((FILE *) (XFASTINT (XCAR (stream)) << 16
+ | XFASTINT (XCDR (stream))));
if (--load_in_progress < 0) load_in_progress = 0;
return Qnil;
}
{
#ifndef WINDOWSNT
Lisp_Object tail;
- for (tail = load_descriptor_list; !NILP (tail); tail = XCONS (tail)->cdr)
- close (XFASTINT (XCONS (tail)->car));
+ for (tail = load_descriptor_list; !NILP (tail); tail = XCDR (tail))
+ emacs_close (XFASTINT (XCAR (tail)));
#endif
}
\f
/* Search for a file whose name is STR, looking in directories
in the Lisp list PATH, and trying suffixes from SUFFIX.
- SUFFIX is a string containing possible suffixes separated by colons.
On success, returns a file descriptor. On failure, returns -1.
+ SUFFIXES is a list of strings containing possible suffixes.
+ The empty suffix is automatically added iff the list is empty.
+
EXEC_ONLY nonzero means don't open the files,
just look for one that is executable. In this case,
returns 1 on success.
the file actually found should be stored as a Lisp string.
nil is stored there on failure.
- If the file we find is remote, return 0
+ If the file we find is remote, return -2
but store the found remote file name in *STOREPTR.
We do not check for remote files if EXEC_ONLY is nonzero. */
int
-openp (path, str, suffix, storeptr, exec_only)
+openp (path, str, suffixes, storeptr, exec_only)
Lisp_Object path, str;
- char *suffix;
+ Lisp_Object suffixes;
Lisp_Object *storeptr;
int exec_only;
{
int want_size;
Lisp_Object filename;
struct stat st;
- struct gcpro gcpro1;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+ Lisp_Object string, tail;
+ int max_suffix_len = 0;
- GCPRO1 (str);
+ for (tail = suffixes; CONSP (tail); tail = XCDR (tail))
+ {
+ CHECK_STRING_CAR (tail);
+ max_suffix_len = max (max_suffix_len,
+ STRING_BYTES (XSTRING (XCAR (tail))));
+ }
+
+ string = filename = Qnil;
+ GCPRO5 (str, string, filename, path, suffixes);
+
if (storeptr)
*storeptr = Qnil;
if (complete_filename_p (str))
absolute = 1;
- for (; !NILP (path); path = Fcdr (path))
+ for (; CONSP (path); path = XCDR (path))
{
- char *nsuffix;
-
- filename = Fexpand_file_name (str, Fcar (path));
+ filename = Fexpand_file_name (str, XCAR (path));
if (!complete_filename_p (filename))
/* If there are non-absolute elts in PATH (eg ".") */
/* Of course, this could conceivably lose if luser sets
/* Calculate maximum size of any filename made from
this path element/specified file name and any possible suffix. */
- want_size = strlen (suffix) + XSTRING (filename)->size + 1;
+ want_size = max_suffix_len + STRING_BYTES (XSTRING (filename)) + 1;
if (fn_size < want_size)
fn = (char *) alloca (fn_size = 100 + want_size);
- nsuffix = suffix;
-
/* Loop over suffixes. */
- while (1)
+ for (tail = NILP (suffixes) ? default_suffixes : suffixes;
+ CONSP (tail); tail = XCDR (tail))
{
- char *esuffix = (char *) index (nsuffix, ':');
- int lsuffix = esuffix ? esuffix - nsuffix : strlen (nsuffix);
+ int lsuffix = STRING_BYTES (XSTRING (XCAR (tail)));
Lisp_Object handler;
/* Concatenate path element/specified name with the suffix.
&& XSTRING (filename)->data[1] == ':')
{
strncpy (fn, XSTRING (filename)->data + 2,
- XSTRING (filename)->size - 2);
- fn[XSTRING (filename)->size - 2] = 0;
+ STRING_BYTES (XSTRING (filename)) - 2);
+ fn[STRING_BYTES (XSTRING (filename)) - 2] = 0;
}
else
{
- strncpy (fn, XSTRING (filename)->data, XSTRING (filename)->size);
- fn[XSTRING (filename)->size] = 0;
+ strncpy (fn, XSTRING (filename)->data,
+ STRING_BYTES (XSTRING (filename)));
+ fn[STRING_BYTES (XSTRING (filename))] = 0;
}
if (lsuffix != 0) /* Bug happens on CCI if lsuffix is 0. */
- strncat (fn, nsuffix, lsuffix);
-
+ strncat (fn, XSTRING (XCAR (tail))->data, lsuffix);
+
/* Check that the file exists and is not a directory. */
- if (absolute)
- handler = Qnil;
- else
- handler = Ffind_file_name_handler (filename, Qfile_exists_p);
- if (! NILP (handler) && ! exec_only)
+ /* We used to only check for handlers on non-absolute file names:
+ if (absolute)
+ handler = Qnil;
+ else
+ handler = Ffind_file_name_handler (filename, Qfile_exists_p);
+ It's not clear why that was the case and it breaks things like
+ (load "/bar.el") where the file is actually "/bar.el.gz". */
+ handler = Ffind_file_name_handler (filename, Qfile_exists_p);
+ if (!NILP (handler) && !exec_only)
{
- Lisp_Object string;
int exists;
string = build_string (fn);
- exists = ! NILP (exec_only ? Ffile_executable_p (string)
- : Ffile_readable_p (string));
- if (exists
- && ! NILP (Ffile_directory_p (build_string (fn))))
+ exists = !NILP (Ffile_readable_p (string));
+ if (exists && !NILP (Ffile_directory_p (build_string (fn))))
exists = 0;
if (exists)
if (storeptr)
*storeptr = build_string (fn);
UNGCPRO;
- return 0;
+ return -2;
}
}
else
if (exec_only)
fd = (access (fn, X_OK) == 0) ? 1 : -1;
else
- fd = open (fn, O_RDONLY, 0);
+ fd = emacs_open (fn, O_RDONLY, 0);
if (fd >= 0)
{
}
}
}
-
- /* Advance to next suffix. */
- if (esuffix == 0)
- break;
- nsuffix += lsuffix + 1;
}
if (absolute)
break;
register Lisp_Object tem, tem2;
register int foundit, loading;
- /* Don't bother recording anything for preloaded files. */
- if (!NILP (Vpurify_flag))
- return;
-
loading = stream || !NARROWED;
tail = Vload_history;
}
Lisp_Object
-unreadpure () /* Used as unwind-protect function in readevalloop */
+unreadpure (junk) /* Used as unwind-protect function in readevalloop */
+ Lisp_Object junk;
{
read_pure = 0;
return Qnil;
return Qnil;
}
+/* Signal an `end-of-file' error, if possible with file name
+ information. */
+
+static void
+end_of_file_error ()
+{
+ Lisp_Object data;
+
+ if (STRINGP (Vload_file_name))
+ data = Fcons (Vload_file_name, Qnil);
+ else
+ data = Qnil;
+
+ Fsignal (Qend_of_file, data);
+}
+
/* UNIBYTE specifies how to set load_convert_to_unibyte
- for this invocation. */
+ for this invocation.
+ READFUN, if non-nil, is used instead of `read'. */
static void
-readevalloop (readcharfun, stream, sourcename, evalfun, printflag, unibyte)
+readevalloop (readcharfun, stream, sourcename, evalfun, printflag, unibyte, readfun)
Lisp_Object readcharfun;
FILE *stream;
Lisp_Object sourcename;
Lisp_Object (*evalfun) ();
int printflag;
- Lisp_Object unibyte;
+ Lisp_Object unibyte, readfun;
{
register int c;
register Lisp_Object val;
int count = specpdl_ptr - specpdl;
struct gcpro gcpro1;
struct buffer *b = 0;
+ int continue_reading_p;
if (BUFFERP (readcharfun))
b = XBUFFER (readcharfun);
record_unwind_protect (readevalloop_1, load_convert_to_unibyte ? Qt : Qnil);
load_convert_to_unibyte = !NILP (unibyte);
- readchar_backlog = 0;
+ readchar_backlog = -1;
GCPRO1 (sourcename);
LOADHIST_ATTACH (sourcename);
- while (1)
+ continue_reading_p = 1;
+ while (continue_reading_p)
{
if (b != 0 && NILP (b->name))
error ("Reading from killed buffer");
{
UNREAD (c);
read_objects = Qnil;
- if (NILP (Vload_read_function))
- val = read0 (readcharfun);
- else
+ if (!NILP (readfun))
+ {
+ val = call1 (readfun, readcharfun);
+
+ /* If READCHARFUN has set point to ZV, we should
+ stop reading, even if the form read sets point
+ to a different value when evaluated. */
+ if (BUFFERP (readcharfun))
+ {
+ struct buffer *b = XBUFFER (readcharfun);
+ if (BUF_PT (b) == BUF_ZV (b))
+ continue_reading_p = 0;
+ }
+ }
+ else if (! NILP (Vload_read_function))
val = call1 (Vload_read_function, readcharfun);
+ else
+ val = read0 (readcharfun);
}
val = (*evalfun) (val);
+
if (printflag)
{
Vvalues = Fcons (val, Vvalues);
unbind_to (count, Qnil);
}
-#ifndef standalone
-
-DEFUN ("eval-buffer", Feval_buffer, Seval_buffer, 0, 4, "",
- "Execute the current buffer as Lisp code.\n\
-Programs can pass two arguments, BUFFER and PRINTFLAG.\n\
-BUFFER is the buffer to evaluate (nil means use current buffer).\n\
-PRINTFLAG controls printing of output:\n\
-nil means discard it; anything else is stream for print.\n\
-\n\
-If the optional third argument FILENAME is non-nil,\n\
-it specifies the file name to use for `load-history'.\n\
-\n\
-This function preserves the position of point.")
- (buffer, printflag, filename, unibyte)
- Lisp_Object buffer, printflag, filename, unibyte;
+DEFUN ("eval-buffer", Feval_buffer, Seval_buffer, 0, 5, "",
+ doc: /* Execute the current buffer as Lisp code.
+Programs can pass two arguments, BUFFER and PRINTFLAG.
+BUFFER is the buffer to evaluate (nil means use current buffer).
+PRINTFLAG controls printing of output:
+nil means discard it; anything else is stream for print.
+
+If the optional third argument FILENAME is non-nil,
+it specifies the file name to use for `load-history'.
+The optional fourth argument UNIBYTE specifies `load-convert-to-unibyte'
+for this invocation.
+
+The optional fifth argument DO-ALLOW-PRINT, if not-nil, specifies that
+`print' and related functions should work normally even if PRINTFLAG is nil.
+
+This function preserves the position of point. */)
+ (buffer, printflag, filename, unibyte, do_allow_print)
+ Lisp_Object buffer, printflag, filename, unibyte, do_allow_print;
{
int count = specpdl_ptr - specpdl;
Lisp_Object tem, buf;
if (NILP (buf))
error ("No such buffer");
- if (NILP (printflag))
+ if (NILP (printflag) && NILP (do_allow_print))
tem = Qsymbolp;
else
tem = printflag;
specbind (Qstandard_output, tem);
record_unwind_protect (save_excursion_restore, save_excursion_save ());
BUF_SET_PT (XBUFFER (buf), BUF_BEGV (XBUFFER (buf)));
- readevalloop (buf, 0, filename, Feval, !NILP (printflag), unibyte);
+ readevalloop (buf, 0, filename, Feval, !NILP (printflag), unibyte, Qnil);
unbind_to (count, Qnil);
return Qnil;
}
-#if 0
-XDEFUN ("eval-current-buffer", Feval_current_buffer, Seval_current_buffer, 0, 1, "",
- "Execute the current buffer as Lisp code.\n\
-Programs can pass argument PRINTFLAG which controls printing of output:\n\
-nil means discard it; anything else is stream for print.\n\
-\n\
-If there is no error, point does not move. If there is an error,\n\
-point remains at the end of the last character read from the buffer.")
- (printflag)
- Lisp_Object printflag;
-{
- int count = specpdl_ptr - specpdl;
- Lisp_Object tem, cbuf;
-
- cbuf = Fcurrent_buffer ()
-
- if (NILP (printflag))
- tem = Qsymbolp;
- else
- tem = printflag;
- specbind (Qstandard_output, tem);
- record_unwind_protect (save_excursion_restore, save_excursion_save ());
- SET_PT (BEGV);
- readevalloop (cbuf, 0, XBUFFER (cbuf)->filename, Feval,
- !NILP (printflag), Qnil);
- return unbind_to (count, Qnil);
-}
-#endif
-
-DEFUN ("eval-region", Feval_region, Seval_region, 2, 3, "r",
- "Execute the region as Lisp code.\n\
-When called from programs, expects two arguments,\n\
-giving starting and ending indices in the current buffer\n\
-of the text to be executed.\n\
-Programs can pass third argument PRINTFLAG which controls output:\n\
-nil means discard it; anything else is stream for printing it.\n\
-\n\
-This function does not move point.")
- (start, end, printflag)
- Lisp_Object start, end, printflag;
+DEFUN ("eval-region", Feval_region, Seval_region, 2, 4, "r",
+ doc: /* Execute the region as Lisp code.
+When called from programs, expects two arguments,
+giving starting and ending indices in the current buffer
+of the text to be executed.
+Programs can pass third argument PRINTFLAG which controls output:
+nil means discard it; anything else is stream for printing it.
+Also the fourth argument READ-FUNCTION, if non-nil, is used
+instead of `read' to read each expression. It gets one argument
+which is the input stream for reading characters.
+
+This function does not move point. */)
+ (start, end, printflag, read_function)
+ Lisp_Object start, end, printflag, read_function;
{
int count = specpdl_ptr - specpdl;
Lisp_Object tem, cbuf;
Fgoto_char (start);
Fnarrow_to_region (make_number (BEGV), end);
readevalloop (cbuf, 0, XBUFFER (cbuf)->filename, Feval,
- !NILP (printflag), Qnil);
+ !NILP (printflag), Qnil, read_function);
return unbind_to (count, Qnil);
}
-#endif /* standalone */
\f
DEFUN ("read", Fread, Sread, 0, 1, 0,
- "Read one Lisp expression as text from STREAM, return as Lisp object.\n\
-If STREAM is nil, use the value of `standard-input' (which see).\n\
-STREAM or the value of `standard-input' may be:\n\
- a buffer (read from point and advance it)\n\
- a marker (read from where it points and advance it)\n\
- a function (call it with no arguments for each character,\n\
- call it with a char as argument to push a char back)\n\
- a string (takes text from string, starting at the beginning)\n\
- t (read text line using minibuffer and use it).")
- (stream)
+ doc: /* Read one Lisp expression as text from STREAM, return as Lisp object.
+If STREAM is nil, use the value of `standard-input' (which see).
+STREAM or the value of `standard-input' may be:
+ a buffer (read from point and advance it)
+ a marker (read from where it points and advance it)
+ a function (call it with no arguments for each character,
+ call it with a char as argument to push a char back)
+ a string (takes text from string, starting at the beginning)
+ t (read text line using minibuffer and use it, or read from
+ standard input in batch mode). */)
+ (stream)
Lisp_Object stream;
{
extern Lisp_Object Fread_minibuffer ();
if (EQ (stream, Qt))
stream = Qread_char;
- readchar_backlog = 0;
+ readchar_backlog = -1;
new_backquote_flag = 0;
read_objects = Qnil;
-#ifndef standalone
if (EQ (stream, Qread_char))
return Fread_minibuffer (build_string ("Lisp expression: "), Qnil);
-#endif
if (STRINGP (stream))
return Fcar (Fread_from_string (stream, Qnil, Qnil));
}
DEFUN ("read-from-string", Fread_from_string, Sread_from_string, 1, 3, 0,
- "Read one Lisp expression which is represented as text by STRING.\n\
-Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).\n\
-START and END optionally delimit a substring of STRING from which to read;\n\
- they default to 0 and (length STRING) respectively.")
- (string, start, end)
+ doc: /* Read one Lisp expression which is represented as text by STRING.
+Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
+START and END optionally delimit a substring of STRING from which to read;
+ they default to 0 and (length STRING) respectively. */)
+ (string, start, end)
Lisp_Object string, start, end;
{
int startval, endval;
Lisp_Object tem;
- CHECK_STRING (string,0);
+ CHECK_STRING (string);
if (NILP (end))
endval = XSTRING (string)->size;
else
{
- CHECK_NUMBER (end, 2);
+ CHECK_NUMBER (end);
endval = XINT (end);
if (endval < 0 || endval > XSTRING (string)->size)
args_out_of_range (string, end);
startval = 0;
else
{
- CHECK_NUMBER (start, 1);
+ CHECK_NUMBER (start);
startval = XINT (start);
if (startval < 0 || startval > endval)
args_out_of_range (string, start);
{
/* We need the actual character code of this multibyte
characters. */
- unsigned char str[MAX_LENGTH_OF_MULTI_BYTE_FORM];
+ unsigned char str[MAX_MULTIBYTE_LENGTH];
int len = 0;
+ int bytes;
str[len++] = c;
while ((c = READCHAR) >= 0xA0
- && len < MAX_LENGTH_OF_MULTI_BYTE_FORM)
+ && len < MAX_MULTIBYTE_LENGTH)
str[len++] = c;
UNREAD (c);
- return STRING_CHAR (str, len);
+ if (UNIBYTE_STR_AS_MULTIBYTE_P (str, len, bytes))
+ return STRING_CHAR (str, len);
+ /* The byte sequence is not valid as multibyte. Unread all bytes
+ but the first one, and return the first byte. */
+ while (--len > 0)
+ UNREAD (str[len]);
+ return str[0];
}
/* Read a \-escape sequence, assuming we already read the `\'. */
c = READCHAR;
if (c == '\\')
c = read_escape (readcharfun, 0);
- if ((c & 0177) == '?')
- return 0177 | c;
+ if ((c & ~CHAR_MODIFIER_MASK) == '?')
+ return 0177 | (c & CHAR_MODIFIER_MASK);
+ else if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK)))
+ return c | ctrl_modifier;
/* ASCII control chars are made from letters (both cases),
as well as the non-letters within 0100...0137. */
else if ((c & 0137) >= 0101 && (c & 0137) <= 0132)
}
}
+
+/* Read an integer in radix RADIX using READCHARFUN to read
+ characters. RADIX must be in the interval [2..36]; if it isn't, a
+ read error is signaled . Value is the integer read. Signals an
+ error if encountering invalid read syntax or if RADIX is out of
+ range. */
+
+static Lisp_Object
+read_integer (readcharfun, radix)
+ Lisp_Object readcharfun;
+ int radix;
+{
+ int ndigits = 0, invalid_p, c, sign = 0;
+ EMACS_INT number = 0;
+
+ if (radix < 2 || radix > 36)
+ invalid_p = 1;
+ else
+ {
+ number = ndigits = invalid_p = 0;
+ sign = 1;
+
+ c = READCHAR;
+ if (c == '-')
+ {
+ c = READCHAR;
+ sign = -1;
+ }
+ else if (c == '+')
+ c = READCHAR;
+
+ while (c >= 0)
+ {
+ int digit;
+
+ if (c >= '0' && c <= '9')
+ digit = c - '0';
+ else if (c >= 'a' && c <= 'z')
+ digit = c - 'a' + 10;
+ else if (c >= 'A' && c <= 'Z')
+ digit = c - 'A' + 10;
+ else
+ {
+ UNREAD (c);
+ break;
+ }
+
+ if (digit < 0 || digit >= radix)
+ invalid_p = 1;
+
+ number = radix * number + digit;
+ ++ndigits;
+ c = READCHAR;
+ }
+ }
+
+ if (ndigits == 0 || invalid_p)
+ {
+ char buf[50];
+ sprintf (buf, "integer, radix %d", radix);
+ Fsignal (Qinvalid_read_syntax, Fcons (build_string (buf), Qnil));
+ }
+
+ return make_number (sign * number);
+}
+
+
+/* Convert unibyte text in read_buffer to multibyte.
+
+ Initially, *P is a pointer after the end of the unibyte text, and
+ the pointer *END points after the end of read_buffer.
+
+ If read_buffer doesn't have enough room to hold the result
+ of the conversion, reallocate it and adjust *P and *END.
+
+ At the end, make *P point after the result of the conversion, and
+ return in *NCHARS the number of characters in the converted
+ text. */
+
+static void
+to_multibyte (p, end, nchars)
+ char **p, **end;
+ int *nchars;
+{
+ int nbytes;
+
+ parse_str_as_multibyte (read_buffer, *p - read_buffer, &nbytes, nchars);
+ if (read_buffer_size < 2 * nbytes)
+ {
+ int offset = *p - read_buffer;
+ read_buffer_size = 2 * max (read_buffer_size, nbytes);
+ read_buffer = (char *) xrealloc (read_buffer, read_buffer_size);
+ *p = read_buffer + offset;
+ *end = read_buffer + read_buffer_size;
+ }
+
+ if (nbytes != *nchars)
+ nbytes = str_as_multibyte (read_buffer, read_buffer_size,
+ *p - read_buffer, nchars);
+
+ *p = read_buffer + nbytes;
+}
+
+
/* If the next token is ')' or ']' or '.', we store that character
in *PCH and the return value is not interesting. Else, we store
zero in *PCH and we read and return one lisp object.
retry:
c = READCHAR;
- if (c < 0) return Fsignal (Qend_of_file, Qnil);
+ if (c < 0)
+ end_of_file_error ();
switch (c)
{
return read_list (0, readcharfun);
case '[':
- return read_vector (readcharfun);
+ return read_vector (readcharfun, 0);
case ')':
case ']':
if (c == '[')
{
Lisp_Object tmp;
- tmp = read_vector (readcharfun);
+ tmp = read_vector (readcharfun, 0);
if (XVECTOR (tmp)->size < CHAR_TABLE_STANDARD_SLOTS
|| XVECTOR (tmp)->size > CHAR_TABLE_STANDARD_SLOTS + 10)
error ("Invalid size char-table");
if (c == '[')
{
Lisp_Object tmp;
- tmp = read_vector (readcharfun);
+ tmp = read_vector (readcharfun, 0);
if (XVECTOR (tmp)->size != SUB_CHAR_TABLE_STANDARD_SLOTS)
error ("Invalid size char-table");
XSETCHAR_TABLE (tmp, XCHAR_TABLE (tmp));
/* Accept compiled functions at read-time so that we don't have to
build them using function calls. */
Lisp_Object tmp;
- tmp = read_vector (readcharfun);
+ tmp = read_vector (readcharfun, 1);
return Fmake_byte_code (XVECTOR (tmp)->size,
XVECTOR (tmp)->contents);
}
-#ifdef USE_TEXT_PROPERTIES
if (c == '(')
{
Lisp_Object tmp;
Lisp_Object beg, end, plist;
beg = read1 (readcharfun, &ch, 0);
+ end = plist = Qnil;
if (ch == ')')
break;
if (ch == 0)
UNGCPRO;
return tmp;
}
-#endif
+
/* #@NUMBER is used to skip NUMBER following characters.
That's used in .elc files to skip over doc strings
and function definitions. */
if (c >= 0)
UNREAD (c);
-#ifndef WINDOWSNT /* I don't know if filepos works right on Windoze. */
if (load_force_doc_strings && EQ (readcharfun, Qget_file_char))
{
/* If we are supposed to force doc strings into core right now,
record the last string that we skipped,
and record where in the file it comes from. */
+
+ /* But first exchange saved_doc_string
+ with prev_saved_doc_string, so we save two strings. */
+ {
+ char *temp = saved_doc_string;
+ int temp_size = saved_doc_string_size;
+ file_offset temp_pos = saved_doc_string_position;
+ int temp_len = saved_doc_string_length;
+
+ saved_doc_string = prev_saved_doc_string;
+ saved_doc_string_size = prev_saved_doc_string_size;
+ saved_doc_string_position = prev_saved_doc_string_position;
+ saved_doc_string_length = prev_saved_doc_string_length;
+
+ prev_saved_doc_string = temp;
+ prev_saved_doc_string_size = temp_size;
+ prev_saved_doc_string_position = temp_pos;
+ prev_saved_doc_string_length = temp_len;
+ }
+
if (saved_doc_string_size == 0)
{
saved_doc_string_size = nskip + 100;
saved_doc_string_size);
}
- saved_doc_string_position = ftell (instream);
+ saved_doc_string_position = file_tell (instream);
/* Copy that many characters into saved_doc_string. */
for (i = 0; i < nskip && c >= 0; i++)
saved_doc_string_length = i;
}
else
-#endif /* not WINDOWSNT */
{
/* Skip that many characters. */
for (i = 0; i < nskip && c >= 0; i++)
/* #n=object returns object, but associates it with n for #n#. */
if (c == '=')
{
+ /* Make a placeholder for #n# to use temporarily */
+ Lisp_Object placeholder;
+ Lisp_Object cell;
+
+ placeholder = Fcons(Qnil, Qnil);
+ cell = Fcons (make_number (n), placeholder);
+ read_objects = Fcons (cell, read_objects);
+
+ /* Read the object itself. */
tem = read0 (readcharfun);
- read_objects = Fcons (Fcons (make_number (n), tem), read_objects);
+
+ /* Now put it everywhere the placeholder was... */
+ substitute_object_in_subtree (tem, placeholder);
+
+ /* ...and #n# will use the real value from now on. */
+ Fsetcdr (cell, tem);
+
return tem;
}
/* #n# returns a previously read object. */
return XCDR (tem);
/* Fall through to error message. */
}
+ else if (c == 'r' || c == 'R')
+ return read_integer (readcharfun, n);
+
/* Fall through to error message. */
}
+ else if (c == 'x' || c == 'X')
+ return read_integer (readcharfun, 16);
+ else if (c == 'o' || c == 'O')
+ return read_integer (readcharfun, 8);
+ else if (c == 'b' || c == 'B')
+ return read_integer (readcharfun, 2);
UNREAD (c);
Fsignal (Qinvalid_read_syntax, Fcons (make_string ("#", 1), Qnil));
{
Lisp_Object value;
- new_backquote_flag = 1;
+ new_backquote_flag++;
value = read0 (readcharfun);
- new_backquote_flag = 0;
+ new_backquote_flag--;
return Fcons (Qbackquote, Fcons (value, Qnil));
}
comma_type = Qcomma;
}
- new_backquote_flag = 0;
+ new_backquote_flag--;
value = read0 (readcharfun);
- new_backquote_flag = 1;
+ new_backquote_flag++;
return Fcons (comma_type, Fcons (value, Qnil));
}
else
case '?':
{
- register Lisp_Object val;
-
c = READCHAR;
- if (c < 0) return Fsignal (Qend_of_file, Qnil);
+ if (c < 0)
+ end_of_file_error ();
if (c == '\\')
c = read_escape (readcharfun, 0);
return make_number (c);
}
- case '\"':
+ case '"':
{
- register char *p = read_buffer;
- register char *end = read_buffer + read_buffer_size;
+ char *p = read_buffer;
+ char *end = read_buffer + read_buffer_size;
register int c;
/* Nonzero if we saw an escape sequence specifying
a multibyte character. */
while ((c = READCHAR) >= 0
&& c != '\"')
{
- if (end - p < MAX_LENGTH_OF_MULTI_BYTE_FORM)
+ if (end - p < MAX_MULTIBYTE_LENGTH)
{
- char *new = (char *) xrealloc (read_buffer, read_buffer_size *= 2);
- p += new - read_buffer;
- read_buffer += new - read_buffer;
+ int offset = p - read_buffer;
+ read_buffer = (char *) xrealloc (read_buffer,
+ read_buffer_size *= 2);
+ p = read_buffer + offset;
end = read_buffer + read_buffer_size;
}
/* If an escape specifies a non-ASCII single-byte character,
this must be a unibyte string. */
- if (SINGLE_BYTE_CHAR_P ((c & ~CHAR_META))
- && ! ASCII_BYTE_P (c))
+ if (SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK))
+ && ! ASCII_BYTE_P ((c & ~CHAR_MODIFIER_MASK)))
force_singlebyte = 1;
}
- if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_META)))
+ if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK)))
{
- unsigned char workbuf[4];
- unsigned char *str = workbuf;
- int length;
-
- length = non_ascii_char_to_string (c, workbuf, &str);
- if (length > 1)
- force_multibyte = 1;
-
- bcopy (str, p, length);
- p += length;
+ /* Any modifiers for a multibyte character are invalid. */
+ if (c & CHAR_MODIFIER_MASK)
+ error ("Invalid modifier in string");
+ p += CHAR_STRING (c, p);
+ force_multibyte = 1;
}
else
{
else if (c == (CHAR_CTL | '?'))
c = 127;
+ if (c & CHAR_SHIFT)
+ {
+ /* Shift modifier is valid only with [A-Za-z]. */
+ if ((c & 0377) >= 'A' && (c & 0377) <= 'Z')
+ c &= ~CHAR_SHIFT;
+ else if ((c & 0377) >= 'a' && (c & 0377) <= 'z')
+ c = (c & ~CHAR_SHIFT) - ('a' - 'A');
+ }
+
if (c & CHAR_META)
/* Move the meta bit to the right place for a string. */
c = (c & ~CHAR_META) | 0x80;
}
}
if (c < 0)
- return Fsignal (Qend_of_file, Qnil);
+ end_of_file_error ();
/* If purifying, and string starts with \ newline,
return zero instead. This is for doc strings
return make_number (0);
if (force_multibyte)
- nchars = multibyte_chars_in_text (read_buffer, p - read_buffer);
+ to_multibyte (&p, &end, &nchars);
else if (force_singlebyte)
nchars = p - read_buffer;
else if (load_convert_to_unibyte)
{
Lisp_Object string;
- nchars = multibyte_chars_in_text (read_buffer, p - read_buffer);
+ to_multibyte (&p, &end, &nchars);
if (p - read_buffer != nchars)
{
string = make_multibyte_string (read_buffer, nchars,
return Fstring_make_unibyte (string);
}
}
- else if (EQ (readcharfun, Qget_file_char))
- /* Nowadays, reading directly from a file
- is used only for compiled Emacs Lisp files,
- and those always use the Emacs internal encoding. */
- nchars = multibyte_chars_in_text (read_buffer, p - read_buffer);
+ else if (EQ (readcharfun, Qget_file_char)
+ || EQ (readcharfun, Qlambda))
+ {
+ /* Nowadays, reading directly from a file is used only for
+ compiled Emacs Lisp files, and those always use the
+ Emacs internal encoding. Meanwhile, Qlambda is used
+ for reading dynamic byte code (compiled with
+ byte-compile-dynamic = t). */
+ to_multibyte (&p, &end, &nchars);
+ }
else
/* In all other cases, if we read these bytes as
separate characters, treat them as separate characters now. */
case '.':
{
-#ifdef LISP_FLOAT_TYPE
- /* If a period is followed by a number, then we should read it
- as a floating point number. Otherwise, it denotes a dotted
- pair. */
int next_char = READCHAR;
UNREAD (next_char);
- if (! (next_char >= '0' && next_char <= '9'))
-#endif
+ if (next_char <= 040
+ || index ("\"'`,(", next_char))
{
*pch = c;
return Qnil;
default_label:
if (c <= 040) goto retry;
{
- register char *p = read_buffer;
+ char *p = read_buffer;
int quoted = 0;
{
- register char *end = read_buffer + read_buffer_size;
+ char *end = read_buffer + read_buffer_size;
while (c > 040
- && !(c == '\"' || c == '\'' || c == ';' || c == '?'
+ && !(c == '\"' || c == '\'' || c == ';'
|| c == '(' || c == ')'
-#ifndef LISP_FLOAT_TYPE
- /* If we have floating-point support, then we need
- to allow <digits><dot><digits>. */
- || c =='.'
-#endif /* not LISP_FLOAT_TYPE */
- || c == '[' || c == ']' || c == '#'
- ))
+ || c == '[' || c == ']' || c == '#'))
{
- if (end - p < MAX_LENGTH_OF_MULTI_BYTE_FORM)
+ if (end - p < MAX_MULTIBYTE_LENGTH)
{
- register char *new = (char *) xrealloc (read_buffer, read_buffer_size *= 2);
- p += new - read_buffer;
- read_buffer += new - read_buffer;
+ int offset = p - read_buffer;
+ read_buffer = (char *) xrealloc (read_buffer,
+ read_buffer_size *= 2);
+ p = read_buffer + offset;
end = read_buffer + read_buffer_size;
}
+
if (c == '\\')
{
c = READCHAR;
+ if (c == -1)
+ end_of_file_error ();
quoted = 1;
}
if (! SINGLE_BYTE_CHAR_P (c))
- {
- unsigned char workbuf[4];
- unsigned char *str = workbuf;
- int length;
-
- length = non_ascii_char_to_string (c, workbuf, &str);
-
- bcopy (str, p, length);
- p += length;
- }
+ p += CHAR_STRING (c, p);
else
*p++ = c;
if (p == end)
{
- char *new = (char *) xrealloc (read_buffer, read_buffer_size *= 2);
- p += new - read_buffer;
- read_buffer += new - read_buffer;
-/* end = read_buffer + read_buffer_size; */
+ int offset = p - read_buffer;
+ read_buffer = (char *) xrealloc (read_buffer,
+ read_buffer_size *= 2);
+ p = read_buffer + offset;
+ end = read_buffer + read_buffer_size;
}
*p = 0;
if (c >= 0)
if (p1 != p)
{
while (p1 != p && (c = *p1) >= '0' && c <= '9') p1++;
-#ifdef LISP_FLOAT_TYPE
/* Integers can have trailing decimal points. */
if (p1 > read_buffer && p1 < p && *p1 == '.') p1++;
-#endif
if (p1 == p)
/* It is an integer. */
{
-#ifdef LISP_FLOAT_TYPE
if (p1[-1] == '.')
p1[-1] = '\0';
-#endif
if (sizeof (int) == sizeof (EMACS_INT))
XSETINT (val, atoi (read_buffer));
else if (sizeof (long) == sizeof (EMACS_INT))
return val;
}
}
-#ifdef LISP_FLOAT_TYPE
if (isfloat_string (read_buffer))
{
+ /* Compute NaN and infinities using 0.0 in a variable,
+ to cope with compilers that think they are smarter
+ than we are. */
double zero = 0.0;
- double value = atof (read_buffer);
- if (read_buffer[0] == '-' && value == 0.0)
- value *= -1.0;
- /* The only way this can be true, after isfloat_string
+
+ double value;
+
+ /* Negate the value ourselves. This treats 0, NaNs,
+ and infinity properly on IEEE floating point hosts,
+ and works around a common bug where atof ("-0.0")
+ drops the sign. */
+ int negative = read_buffer[0] == '-';
+
+ /* The only way p[-1] can be 'F' or 'N', after isfloat_string
returns 1, is if the input ends in e+INF or e+NaN. */
- if (p[-1] == 'F' || p[-1] == 'N')
+ switch (p[-1])
{
- if (p[-1] == 'N')
- value = zero / zero;
- else if (read_buffer[0] == '-')
- value = - 1.0 / zero;
- else
- value = 1.0 / zero;
+ case 'F':
+ value = 1.0 / zero;
+ break;
+ case 'N':
+ value = zero / zero;
+ break;
+ default:
+ value = atof (read_buffer + negative);
+ break;
}
- return make_float (value);
+
+ return make_float (negative ? - value : value);
}
-#endif
}
if (uninterned_symbol)
}
}
\f
-#ifdef LISP_FLOAT_TYPE
+/* List of nodes we've seen during substitute_object_in_subtree. */
+static Lisp_Object seen_list;
+
+static void
+substitute_object_in_subtree (object, placeholder)
+ Lisp_Object object;
+ Lisp_Object placeholder;
+{
+ Lisp_Object check_object;
+
+ /* We haven't seen any objects when we start. */
+ seen_list = Qnil;
+
+ /* Make all the substitutions. */
+ check_object
+ = substitute_object_recurse (object, placeholder, object);
+
+ /* Clear seen_list because we're done with it. */
+ seen_list = Qnil;
+
+ /* The returned object here is expected to always eq the
+ original. */
+ if (!EQ (check_object, object))
+ error ("Unexpected mutation error in reader");
+}
+
+/* Feval doesn't get called from here, so no gc protection is needed. */
+#define SUBSTITUTE(get_val, set_val) \
+{ \
+ Lisp_Object old_value = get_val; \
+ Lisp_Object true_value \
+ = substitute_object_recurse (object, placeholder,\
+ old_value); \
+ \
+ if (!EQ (old_value, true_value)) \
+ { \
+ set_val; \
+ } \
+}
+
+static Lisp_Object
+substitute_object_recurse (object, placeholder, subtree)
+ Lisp_Object object;
+ Lisp_Object placeholder;
+ Lisp_Object subtree;
+{
+ /* If we find the placeholder, return the target object. */
+ if (EQ (placeholder, subtree))
+ return object;
+
+ /* If we've been to this node before, don't explore it again. */
+ if (!EQ (Qnil, Fmemq (subtree, seen_list)))
+ return subtree;
+
+ /* If this node can be the entry point to a cycle, remember that
+ we've seen it. It can only be such an entry point if it was made
+ by #n=, which means that we can find it as a value in
+ read_objects. */
+ if (!EQ (Qnil, Frassq (subtree, read_objects)))
+ seen_list = Fcons (subtree, seen_list);
+
+ /* Recurse according to subtree's type.
+ Every branch must return a Lisp_Object. */
+ switch (XTYPE (subtree))
+ {
+ case Lisp_Vectorlike:
+ {
+ int i;
+ int length = XINT (Flength(subtree));
+ for (i = 0; i < length; i++)
+ {
+ Lisp_Object idx = make_number (i);
+ SUBSTITUTE (Faref (subtree, idx),
+ Faset (subtree, idx, true_value));
+ }
+ return subtree;
+ }
+
+ case Lisp_Cons:
+ {
+ SUBSTITUTE (Fcar_safe (subtree),
+ Fsetcar (subtree, true_value));
+ SUBSTITUTE (Fcdr_safe (subtree),
+ Fsetcdr (subtree, true_value));
+ return subtree;
+ }
+
+ case Lisp_String:
+ {
+ /* Check for text properties in each interval.
+ substitute_in_interval contains part of the logic. */
+
+ INTERVAL root_interval = XSTRING (subtree)->intervals;
+ Lisp_Object arg = Fcons (object, placeholder);
+
+ traverse_intervals_noorder (root_interval,
+ &substitute_in_interval, arg);
+
+ return subtree;
+ }
+
+ /* Other types don't recurse any further. */
+ default:
+ return subtree;
+ }
+}
+
+/* Helper function for substitute_object_recurse. */
+static void
+substitute_in_interval (interval, arg)
+ INTERVAL interval;
+ Lisp_Object arg;
+{
+ Lisp_Object object = Fcar (arg);
+ Lisp_Object placeholder = Fcdr (arg);
+
+ SUBSTITUTE(interval->plist, interval->plist = true_value);
+}
+
+\f
#define LEAD_INT 1
#define DOT_CHAR 2
#define TRAIL_INT 4
|| state == (LEAD_INT|DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT)
|| state == (DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT)));
}
-#endif /* LISP_FLOAT_TYPE */
+
\f
static Lisp_Object
-read_vector (readcharfun)
+read_vector (readcharfun, bytecodeflag)
Lisp_Object readcharfun;
+ int bytecodeflag;
{
register int i;
register int size;
register Lisp_Object *ptr;
- register Lisp_Object tem, vector;
+ register Lisp_Object tem, item, vector;
register struct Lisp_Cons *otem;
Lisp_Object len;
len = Flength (tem);
vector = (read_pure ? make_pure_vector (XINT (len)) : Fmake_vector (len, Qnil));
-
size = XVECTOR (vector)->size;
ptr = XVECTOR (vector)->contents;
for (i = 0; i < size; i++)
{
- ptr[i] = read_pure ? Fpurecopy (Fcar (tem)) : Fcar (tem);
+ item = Fcar (tem);
+ /* If `load-force-doc-strings' is t when reading a lazily-loaded
+ bytecode object, the docstring containing the bytecode and
+ constants values must be treated as unibyte and passed to
+ Fread, to get the actual bytecode string and constants vector. */
+ if (bytecodeflag && load_force_doc_strings)
+ {
+ if (i == COMPILED_BYTECODE)
+ {
+ if (!STRINGP (item))
+ error ("invalid byte code");
+
+ /* Delay handling the bytecode slot until we know whether
+ it is lazily-loaded (we can tell by whether the
+ constants slot is nil). */
+ ptr[COMPILED_CONSTANTS] = item;
+ item = Qnil;
+ }
+ else if (i == COMPILED_CONSTANTS)
+ {
+ Lisp_Object bytestr = ptr[COMPILED_CONSTANTS];
+
+ if (NILP (item))
+ {
+ /* Coerce string to unibyte (like string-as-unibyte,
+ but without generating extra garbage and
+ guaranteeing no change in the contents). */
+ XSTRING (bytestr)->size = STRING_BYTES (XSTRING (bytestr));
+ SET_STRING_BYTES (XSTRING (bytestr), -1);
+
+ item = Fread (bytestr);
+ if (!CONSP (item))
+ error ("invalid byte code");
+
+ otem = XCONS (item);
+ bytestr = XCAR (item);
+ item = XCDR (item);
+ free_cons (otem);
+ }
+
+ /* Now handle the bytecode slot. */
+ ptr[COMPILED_BYTECODE] = read_pure ? Fpurecopy (bytestr) : bytestr;
+ }
+ }
+ ptr[i] = read_pure ? Fpurecopy (item) : item;
otem = XCONS (tem);
tem = Fcdr (tem);
free_cons (otem);
{
GCPRO2 (val, tail);
if (!NILP (tail))
- XCONS (tail)->cdr = read0 (readcharfun);
+ XSETCDR (tail, read0 (readcharfun));
else
val = read0 (readcharfun);
read1 (readcharfun, &ch, 0);
{
/* Get a doc string from the file we are loading.
If it's in saved_doc_string, get it from there. */
- int pos = XINT (XCONS (val)->cdr);
+ int pos = XINT (XCDR (val));
+ /* Position is negative for user variables. */
+ if (pos < 0) pos = -pos;
if (pos >= saved_doc_string_position
&& pos < (saved_doc_string_position
+ saved_doc_string_length))
return make_string (saved_doc_string + start,
to - start);
}
+ /* Look in prev_saved_doc_string the same way. */
+ else if (pos >= prev_saved_doc_string_position
+ && pos < (prev_saved_doc_string_position
+ + prev_saved_doc_string_length))
+ {
+ int start = pos - prev_saved_doc_string_position;
+ int from, to;
+
+ /* Process quoting with ^A,
+ and find the end of the string,
+ which is marked with ^_ (037). */
+ for (from = start, to = start;
+ prev_saved_doc_string[from] != 037;)
+ {
+ int c = prev_saved_doc_string[from++];
+ if (c == 1)
+ {
+ c = prev_saved_doc_string[from++];
+ if (c == 1)
+ prev_saved_doc_string[to++] = c;
+ else if (c == '0')
+ prev_saved_doc_string[to++] = 0;
+ else if (c == '_')
+ prev_saved_doc_string[to++] = 037;
+ }
+ else
+ prev_saved_doc_string[to++] = c;
+ }
+
+ return make_string (prev_saved_doc_string + start,
+ to - start);
+ }
else
- return read_doc_string (val);
+ return get_doc_string (val, 0, 0);
}
return val;
? pure_cons (elt, Qnil)
: Fcons (elt, Qnil));
if (!NILP (tail))
- XCONS (tail)->cdr = tem;
+ XSETCDR (tail, tem);
else
val = tem;
tail = tem;
}
\f
DEFUN ("intern", Fintern, Sintern, 1, 2, 0,
- "Return the canonical symbol whose name is STRING.\n\
-If there is none, one is created by this function and returned.\n\
-A second optional argument specifies the obarray to use;\n\
-it defaults to the value of `obarray'.")
- (string, obarray)
+ doc: /* Return the canonical symbol whose name is STRING.
+If there is none, one is created by this function and returned.
+A second optional argument specifies the obarray to use;
+it defaults to the value of `obarray'. */)
+ (string, obarray)
Lisp_Object string, obarray;
{
register Lisp_Object tem, sym, *ptr;
if (NILP (obarray)) obarray = Vobarray;
obarray = check_obarray (obarray);
- CHECK_STRING (string, 0);
+ CHECK_STRING (string);
tem = oblookup (obarray, XSTRING (string)->data,
XSTRING (string)->size,
if (!NILP (Vpurify_flag))
string = Fpurecopy (string);
sym = Fmake_symbol (string);
- XSYMBOL (sym)->obarray = obarray;
+
+ if (EQ (obarray, initial_obarray))
+ XSYMBOL (sym)->interned = SYMBOL_INTERNED_IN_INITIAL_OBARRAY;
+ else
+ XSYMBOL (sym)->interned = SYMBOL_INTERNED;
if ((XSTRING (string)->data[0] == ':')
&& EQ (obarray, initial_obarray))
- XSYMBOL (sym)->value = sym;
+ {
+ XSYMBOL (sym)->constant = 1;
+ XSYMBOL (sym)->value = sym;
+ }
ptr = &XVECTOR (obarray)->contents[XINT (tem)];
if (SYMBOLP (*ptr))
}
DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 2, 0,
- "Return the canonical symbol whose name is STRING, or nil if none exists.\n\
-A second optional argument specifies the obarray to use;\n\
-it defaults to the value of `obarray'.")
- (string, obarray)
- Lisp_Object string, obarray;
+ doc: /* Return the canonical symbol named NAME, or nil if none exists.
+NAME may be a string or a symbol. If it is a symbol, that exact
+symbol is searched for.
+A second optional argument specifies the obarray to use;
+it defaults to the value of `obarray'. */)
+ (name, obarray)
+ Lisp_Object name, obarray;
{
register Lisp_Object tem;
+ struct Lisp_String *string;
if (NILP (obarray)) obarray = Vobarray;
obarray = check_obarray (obarray);
- CHECK_STRING (string, 0);
+ if (!SYMBOLP (name))
+ {
+ CHECK_STRING (name);
+ string = XSTRING (name);
+ }
+ else
+ string = XSYMBOL (name)->name;
- tem = oblookup (obarray, XSTRING (string)->data,
- XSTRING (string)->size,
- STRING_BYTES (XSTRING (string)));
- if (!INTEGERP (tem))
+ tem = oblookup (obarray, string->data, string->size, STRING_BYTES (string));
+ if (INTEGERP (tem) || (SYMBOLP (name) && !EQ (name, tem)))
+ return Qnil;
+ else
return tem;
- return Qnil;
}
\f
DEFUN ("unintern", Funintern, Sunintern, 1, 2, 0,
- "Delete the symbol named NAME, if any, from OBARRAY.\n\
-The value is t if a symbol was found and deleted, nil otherwise.\n\
-NAME may be a string or a symbol. If it is a symbol, that symbol\n\
-is deleted, if it belongs to OBARRAY--no other symbol is deleted.\n\
-OBARRAY defaults to the value of the variable `obarray'.")
- (name, obarray)
+ doc: /* Delete the symbol named NAME, if any, from OBARRAY.
+The value is t if a symbol was found and deleted, nil otherwise.
+NAME may be a string or a symbol. If it is a symbol, that symbol
+is deleted, if it belongs to OBARRAY--no other symbol is deleted.
+OBARRAY defaults to the value of the variable `obarray'. */)
+ (name, obarray)
Lisp_Object name, obarray;
{
register Lisp_Object string, tem;
XSETSTRING (string, XSYMBOL (name)->name);
else
{
- CHECK_STRING (name, 0);
+ CHECK_STRING (name);
string = name;
}
if (SYMBOLP (name) && !EQ (name, tem))
return Qnil;
- XSYMBOL (tem)->obarray = Qnil;
+ XSYMBOL (tem)->interned = SYMBOL_UNINTERNED;
+ XSYMBOL (tem)->constant = 0;
+ XSYMBOL (tem)->indirect_variable = 0;
hash = oblookup_last_bucket_number;
{
register int i;
register Lisp_Object tail;
- CHECK_VECTOR (obarray, 1);
+ CHECK_VECTOR (obarray);
for (i = XVECTOR (obarray)->size - 1; i >= 0; i--)
{
tail = XVECTOR (obarray)->contents[i];
}
DEFUN ("mapatoms", Fmapatoms, Smapatoms, 1, 2, 0,
- "Call FUNCTION on every symbol in OBARRAY.\n\
-OBARRAY defaults to the value of `obarray'.")
- (function, obarray)
+ doc: /* Call FUNCTION on every symbol in OBARRAY.
+OBARRAY defaults to the value of `obarray'. */)
+ (function, obarray)
Lisp_Object function, obarray;
{
- Lisp_Object tem;
-
if (NILP (obarray)) obarray = Vobarray;
obarray = check_obarray (obarray);
initial_obarray = Vobarray;
staticpro (&initial_obarray);
/* Intern nil in the obarray */
- XSYMBOL (Qnil)->obarray = Vobarray;
+ XSYMBOL (Qnil)->interned = SYMBOL_INTERNED_IN_INITIAL_OBARRAY;
+ XSYMBOL (Qnil)->constant = 1;
+
/* These locals are to kludge around a pyramid compiler bug. */
hash = hash_string ("nil", 3);
/* Separate statement here to avoid VAXC bug. */
XSYMBOL (Qnil)->value = Qnil;
XSYMBOL (Qnil)->plist = Qnil;
XSYMBOL (Qt)->value = Qt;
+ XSYMBOL (Qt)->constant = 1;
/* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
Vpurify_flag = Qt;
Qvariable_documentation = intern ("variable-documentation");
staticpro (&Qvariable_documentation);
- read_buffer_size = 100 + MAX_LENGTH_OF_MULTI_BYTE_FORM;
- read_buffer = (char *) malloc (read_buffer_size);
+ read_buffer_size = 100 + MAX_MULTIBYTE_LENGTH;
+ read_buffer = (char *) xmalloc (read_buffer_size);
}
\f
void
/* Define an "integer variable"; a symbol whose value is forwarded
to a C variable of type int. Sample call: */
- /* DEFVAR_INT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
+ /* DEFVAR_INT ("indent-tabs-mode", &indent_tabs_mode, "Documentation"); */
void
defvar_int (namestring, address)
char *namestring;
val = allocate_misc ();
XMISCTYPE (val) = Lisp_Misc_Intfwd;
XINTFWD (val)->intvar = address;
- XSYMBOL (sym)->value = val;
+ SET_SYMBOL_VALUE (sym, val);
}
/* Similar but define a variable whose value is T if address contains 1,
val = allocate_misc ();
XMISCTYPE (val) = Lisp_Misc_Boolfwd;
XBOOLFWD (val)->boolvar = address;
- XSYMBOL (sym)->value = val;
+ SET_SYMBOL_VALUE (sym, val);
+ Vbyte_boolean_vars = Fcons (sym, Vbyte_boolean_vars);
}
/* Similar but define a variable whose value is the Lisp Object stored
val = allocate_misc ();
XMISCTYPE (val) = Lisp_Misc_Objfwd;
XOBJFWD (val)->objvar = address;
- XSYMBOL (sym)->value = val;
+ SET_SYMBOL_VALUE (sym, val);
}
void
staticpro (address);
}
-#ifndef standalone
-
/* Similar but define a variable whose value is the Lisp Object stored in
the current buffer. address is the address of the slot in the buffer
that is current now. */
XMISCTYPE (val) = Lisp_Misc_Buffer_Objfwd;
XBUFFER_OBJFWD (val)->offset = offset;
- XSYMBOL (sym)->value = val;
- *(Lisp_Object *)(offset + (char *)&buffer_local_symbols) = sym;
- *(Lisp_Object *)(offset + (char *)&buffer_local_types) = type;
- if (XINT (*(Lisp_Object *)(offset + (char *)&buffer_local_flags)) == 0)
+ SET_SYMBOL_VALUE (sym, val);
+ PER_BUFFER_SYMBOL (offset) = sym;
+ PER_BUFFER_TYPE (offset) = type;
+
+ if (PER_BUFFER_IDX (offset) == 0)
/* Did a DEFVAR_PER_BUFFER without initializing the corresponding
slot of buffer_local_flags */
abort ();
}
-#endif /* standalone */
/* Similar but define a variable whose value is the Lisp Object stored
at a particular offset in the current kboard object. */
val = allocate_misc ();
XMISCTYPE (val) = Lisp_Misc_Kboard_Objfwd;
XKBOARD_OBJFWD (val)->offset = offset;
- XSYMBOL (sym)->value = val;
+ SET_SYMBOL_VALUE (sym, val);
}
\f
/* Record the value of load-path used at the start of dumping
char *normal;
int turn_off_warning = 0;
-#ifdef HAVE_SETLOCALE
- /* Make sure numbers are parsed as we expect. */
- setlocale (LC_NUMERIC, "C");
-#endif /* HAVE_SETLOCALE */
-
/* Compute the default load-path. */
#ifdef CANNOT_DUMP
normal = PATH_LOADSEARCH;
for (path_tail = Vload_path;
!NILP (path_tail);
- path_tail = XCONS (path_tail)->cdr)
+ path_tail = XCDR (path_tail))
{
Lisp_Object dirfile;
dirfile = Fcar (path_tail);
dirfile = Fdirectory_file_name (dirfile);
if (access (XSTRING (dirfile)->data, 0) < 0)
dir_warning ("Warning: Lisp directory `%s' does not exist.\n",
- XCONS (path_tail)->car);
+ XCAR (path_tail));
}
}
}
load_descriptor_list = Qnil;
Vstandard_input = Qt;
+ Vloads_in_progress = Qnil;
}
/* Print a warning, using format string FORMAT, that directory DIRNAME
defsubr (&Smapatoms);
DEFVAR_LISP ("obarray", &Vobarray,
- "Symbol table for use by `intern' and `read'.\n\
-It is a vector whose length ought to be prime for best results.\n\
-The vector's contents don't make sense if examined from Lisp programs;\n\
-to find all the symbols in an obarray, use `mapatoms'.");
+ doc: /* Symbol table for use by `intern' and `read'.
+It is a vector whose length ought to be prime for best results.
+The vector's contents don't make sense if examined from Lisp programs;
+to find all the symbols in an obarray, use `mapatoms'. */);
DEFVAR_LISP ("values", &Vvalues,
- "List of values of all expressions which were read, evaluated and printed.\n\
-Order is reverse chronological.");
+ doc: /* List of values of all expressions which were read, evaluated and printed.
+Order is reverse chronological. */);
DEFVAR_LISP ("standard-input", &Vstandard_input,
- "Stream for read to get input from.\n\
-See documentation of `read' for possible values.");
+ doc: /* Stream for read to get input from.
+See documentation of `read' for possible values. */);
Vstandard_input = Qt;
DEFVAR_LISP ("load-path", &Vload_path,
- "*List of directories to search for files to load.\n\
-Each element is a string (directory name) or nil (try default directory).\n\
-Initialized based on EMACSLOADPATH environment variable, if any,\n\
-otherwise to default specified by file `paths.h' when Emacs was built.");
+ doc: /* *List of directories to search for files to load.
+Each element is a string (directory name) or nil (try default directory).
+Initialized based on EMACSLOADPATH environment variable, if any,
+otherwise to default specified by file `epaths.h' when Emacs was built. */);
+
+ DEFVAR_LISP ("load-suffixes", &Vload_suffixes,
+ doc: /* *List of suffixes to try for files to load.
+This list should not include the empty string. */);
+ Vload_suffixes = Fcons (build_string (".elc"),
+ Fcons (build_string (".el"), Qnil));
+ /* We don't use empty_string because it's not initialized yet. */
+ default_suffixes = Fcons (build_string (""), Qnil);
+ staticpro (&default_suffixes);
DEFVAR_BOOL ("load-in-progress", &load_in_progress,
- "Non-nil iff inside of `load'.");
+ doc: /* Non-nil iff inside of `load'. */);
DEFVAR_LISP ("after-load-alist", &Vafter_load_alist,
- "An alist of expressions to be evalled when particular files are loaded.\n\
-Each element looks like (FILENAME FORMS...).\n\
-When `load' is run and the file-name argument is FILENAME,\n\
-the FORMS in the corresponding element are executed at the end of loading.\n\n\
-FILENAME must match exactly! Normally FILENAME is the name of a library,\n\
-with no directory specified, since that is how `load' is normally called.\n\
-An error in FORMS does not undo the load,\n\
-but does prevent execution of the rest of the FORMS.");
+ doc: /* An alist of expressions to be evalled when particular files are loaded.
+Each element looks like (FILENAME FORMS...).
+When `load' is run and the file-name argument is FILENAME,
+the FORMS in the corresponding element are executed at the end of loading.
+
+FILENAME must match exactly! Normally FILENAME is the name of a library,
+with no directory specified, since that is how `load' is normally called.
+An error in FORMS does not undo the load,
+but does prevent execution of the rest of the FORMS.
+FILENAME can also be a symbol (a feature) and FORMS are then executed
+when the corresponding call to `provide' is made. */);
Vafter_load_alist = Qnil;
DEFVAR_LISP ("load-history", &Vload_history,
- "Alist mapping source file names to symbols and features.\n\
-Each alist element is a list that starts with a file name,\n\
-except for one element (optional) that starts with nil and describes\n\
-definitions evaluated from buffers not visiting files.\n\
-The remaining elements of each list are symbols defined as functions\n\
-or variables, and cons cells `(provide . FEATURE)' and `(require . FEATURE)'.");
+ doc: /* Alist mapping source file names to symbols and features.
+Each alist element is a list that starts with a file name,
+except for one element (optional) that starts with nil and describes
+definitions evaluated from buffers not visiting files.
+The remaining elements of each list are symbols defined as functions
+or variables, and cons cells `(provide . FEATURE)', `(require . FEATURE)',
+and `(autoload . SYMBOL)'. */);
Vload_history = Qnil;
DEFVAR_LISP ("load-file-name", &Vload_file_name,
- "Full name of file being loaded by `load'.");
+ doc: /* Full name of file being loaded by `load'. */);
Vload_file_name = Qnil;
+ DEFVAR_LISP ("user-init-file", &Vuser_init_file,
+ doc: /* File name, including directory, of user's initialization file.
+If the file loaded had extension `.elc' and there was a corresponding `.el'
+file, this variable contains the name of the .el file, suitable for use
+by functions like `custom-save-all' which edit the init file. */);
+ Vuser_init_file = Qnil;
+
DEFVAR_LISP ("current-load-list", &Vcurrent_load_list,
- "Used for internal purposes by `load'.");
+ doc: /* Used for internal purposes by `load'. */);
Vcurrent_load_list = Qnil;
DEFVAR_LISP ("load-read-function", &Vload_read_function,
- "Function used by `load' and `eval-region' for reading expressions.\n\
-The default is nil, which means use the function `read'.");
+ doc: /* Function used by `load' and `eval-region' for reading expressions.
+The default is nil, which means use the function `read'. */);
Vload_read_function = Qnil;
DEFVAR_LISP ("load-source-file-function", &Vload_source_file_function,
- "Function called in `load' for loading an Emacs lisp source file.\n\
-This function is for doing code conversion before reading the source file.\n\
-If nil, loading is done without any code conversion.\n\
-Arguments are FULLNAME, FILE, NOERROR, NOMESSAGE, where\n\
- FULLNAME is the full name of FILE.\n\
-See `load' for the meaning of the remaining arguments.");
+ doc: /* Function called in `load' for loading an Emacs lisp source file.
+This function is for doing code conversion before reading the source file.
+If nil, loading is done without any code conversion.
+Arguments are FULLNAME, FILE, NOERROR, NOMESSAGE, where
+ FULLNAME is the full name of FILE.
+See `load' for the meaning of the remaining arguments. */);
Vload_source_file_function = Qnil;
DEFVAR_BOOL ("load-force-doc-strings", &load_force_doc_strings,
- "Non-nil means `load' should force-load all dynamic doc strings.\n\
-This is useful when the file being loaded is a temporary copy.");
+ doc: /* Non-nil means `load' should force-load all dynamic doc strings.
+This is useful when the file being loaded is a temporary copy. */);
load_force_doc_strings = 0;
DEFVAR_BOOL ("load-convert-to-unibyte", &load_convert_to_unibyte,
- "Non-nil means `load' converts strings to unibyte whenever possible.\n\
-This is normally used in `load-with-code-conversion'\n\
-for loading non-compiled files.");
+ doc: /* Non-nil means `read' converts strings to unibyte whenever possible.
+This is normally bound by `load' and `eval-buffer' to control `read',
+and is not meant for users to change. */);
load_convert_to_unibyte = 0;
DEFVAR_LISP ("source-directory", &Vsource_directory,
- "Directory in which Emacs sources were found when Emacs was built.\n\
-You cannot count on them to still be there!");
+ doc: /* Directory in which Emacs sources were found when Emacs was built.
+You cannot count on them to still be there! */);
Vsource_directory
= Fexpand_file_name (build_string ("../"),
Fcar (decode_env_path (0, PATH_DUMPLOADSEARCH)));
DEFVAR_LISP ("preloaded-file-list", &Vpreloaded_file_list,
- "List of files that were preloaded (when dumping Emacs).");
+ doc: /* List of files that were preloaded (when dumping Emacs). */);
Vpreloaded_file_list = Qnil;
+ DEFVAR_LISP ("byte-boolean-vars", &Vbyte_boolean_vars,
+ doc: /* List of all DEFVAR_BOOL variables, used by the byte code optimizer. */);
+ Vbyte_boolean_vars = Qnil;
+
+ DEFVAR_BOOL ("load-dangerous-libraries", &load_dangerous_libraries,
+ doc: /* Non-nil means load dangerous compiled Lisp files.
+Some versions of XEmacs use different byte codes than Emacs. These
+incompatible byte codes can make Emacs crash when it tries to execute
+them. */);
+ load_dangerous_libraries = 0;
+
+ DEFVAR_LISP ("bytecomp-version-regexp", &Vbytecomp_version_regexp,
+ doc: /* Regular expression matching safe to load compiled Lisp files.
+When Emacs loads a compiled Lisp file, it reads the first 512 bytes
+from the file, and matches them against this regular expression.
+When the regular expression matches, the file is considered to be safe
+to load. See also `load-dangerous-libraries'. */);
+ Vbytecomp_version_regexp
+ = build_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
+
+ DEFVAR_LISP ("recursive-load-depth-limit", &Vrecursive_load_depth_limit,
+ doc: /* Limit for depth of recursive loads.
+Value should be either an integer > 0 specifying the limit, or nil for
+no limit. */);
+ Vrecursive_load_depth_limit = make_number (50);
+
/* Vsource_directory was initialized in init_lread. */
load_descriptor_list = Qnil;
staticpro (&read_objects);
read_objects = Qnil;
+ staticpro (&seen_list);
+
+ Vloads_in_progress = Qnil;
+ staticpro (&Vloads_in_progress);
}