/* Lisp parsing and input streams.
Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995,
1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006 Free Software Foundation, Inc.
+ 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
#include "frame.h"
#include "termhooks.h"
#include "coding.h"
+#include "blockinput.h"
#ifdef lint
#include <sys/inode.h>
extern Lisp_Object Qevent_symbol_element_mask;
extern Lisp_Object Qfile_exists_p;
-/* non-zero iff inside `load' */
+/* non-zero if inside `load' */
int load_in_progress;
/* Directory in which the sources were found. */
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;
+static Lisp_Object Vold_style_backquotes, Qold_style_backquotes;
/* A list of file names for files being loaded in Fload. Used to
check for recursive loads. */
if (EQ (readcharfun, Qget_file_char))
{
+ BLOCK_INPUT;
c = getc (instream);
#ifdef EINTR
/* Interrupted reads have been observed while reading over the network */
while (c == EOF && ferror (instream) && errno == EINTR)
{
+ UNBLOCK_INPUT;
QUIT;
+ BLOCK_INPUT;
clearerr (instream);
c = getc (instream);
}
#endif
+ UNBLOCK_INPUT;
return c;
}
else if (EQ (readcharfun, Qlambda))
read_bytecode_char (1);
else if (EQ (readcharfun, Qget_file_char))
- ungetc (c, instream);
+ {
+ BLOCK_INPUT;
+ ungetc (c, instream);
+ UNBLOCK_INPUT;
+ }
else
call1 (readcharfun, make_number (c));
}
/* Read until we get an acceptable event. */
retry:
- do
+ do
val = read_char (0, 0, 0, (input_method ? Qnil : Qt), 0,
NUMBERP (seconds) ? &end_time : NULL);
while (INTEGERP (val) && XINT (val) == -2); /* wrong_kboard_jmpbuf */
()
{
register Lisp_Object val;
+ BLOCK_INPUT;
XSETINT (val, getc (instream));
+ UNBLOCK_INPUT;
return val;
}
\f
-/* Value is non-zero if the file asswociated with file descriptor FD
+/* Value is non-zero if the file associated 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
return Qnil;
}
+static Lisp_Object
+load_warn_old_style_backquotes (file)
+ Lisp_Object file;
+{
+ if (!NILP (Vold_style_backquotes))
+ {
+ Lisp_Object args[2];
+ args[0] = build_string ("Loading `%s': old-style backquotes detected!");
+ args[1] = file;
+ Fmessage (2, args);
+ }
+ return Qnil;
+}
+
DEFUN ("get-load-suffixes", Fget_load_suffixes, Sget_load_suffixes, 0, 0, 0,
doc: /* Return the suffixes that `load' should try if a suffix is \
required.
doc: /* Execute a file of Lisp code named FILE.
First try FILE with `.elc' appended, then try with `.el',
then try FILE unmodified (the exact suffixes in the exact order are
-determined by `load-suffixes'). Environment variable references in
+determined by `load-suffixes'). Environment variable references in
FILE are replaced with their values by calling `substitute-in-file-name'.
This function searches the directories in `load-path'.
register FILE *stream;
register int fd = -1;
int count = SPECPDL_INDEX ();
- Lisp_Object temp;
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object found, efound, hist_file_name;
/* 1 means we printed the ".el is newer" message. */
tmp))
: found) ;
+ /* Check for the presence of old-style quotes and warn about them. */
+ specbind (Qold_style_backquotes, Qnil);
+ record_unwind_protect (load_warn_old_style_backquotes, file);
+
if (!bcmp (SDATA (found) + SBYTES (found) - 4,
".elc", 4))
/* Load .elc files directly, but not when they are
{
FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
if (stream != NULL)
- fclose (stream);
+ {
+ BLOCK_INPUT;
+ fclose (stream);
+ UNBLOCK_INPUT;
+ }
if (--load_in_progress < 0) load_in_progress = 0;
return Qnil;
}
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.
+ The empty suffix is automatically added if the list is empty.
PREDICATE non-nil means don't open the files,
just look for one that satisfies the predicate. In this case,
fn = (char *) alloca (fn_size = 100 + want_size);
/* Loop over suffixes. */
- for (tail = NILP (suffixes) ? Fcons (build_string (""), Qnil) : suffixes;
+ for (tail = NILP (suffixes) ? Fcons (empty_unibyte_string, Qnil) : suffixes;
CONSP (tail); tail = XCDR (tail))
{
int lsuffix = SBYTES (XCAR (tail));
static void
end_of_file_error ()
{
- Lisp_Object data;
-
if (STRINGP (Vload_file_name))
xsignal1 (Qend_of_file, Vload_file_name);
}
/* Ignore whitespace here, so we can detect eof. */
- if (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r')
+ if (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r'
+ || c == 0x8a0) /* NBSP */
goto read_next;
if (!NILP (Vpurify_flag) && c == '(')
case 's':
c = READCHAR;
- if (c != '-')
+ if (stringp || c != '-')
{
UNREAD (c);
return ' ';
case '`':
if (first_in_list)
- goto default_label;
+ {
+ Vold_style_backquotes = Qt;
+ goto default_label;
+ }
else
{
Lisp_Object value;
return Fcons (comma_type, Fcons (value, Qnil));
}
else
- goto default_label;
+ {
+ Vold_style_backquotes = Qt;
+ goto default_label;
+ }
case '?':
{
default:
default_label:
if (c <= 040) goto retry;
+ if (c == 0x8a0) /* NBSP */
+ goto retry;
{
char *p = read_buffer;
int quoted = 0;
char *end = read_buffer + read_buffer_size;
while (c > 040
+ && c != 0x8a0 /* NBSP */
&& (c >= 0200
|| (!index ("\"';()[]#", c)
&& !(!first_in_list && c == '`')
staticpro (address);
}
-/* 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. */
-
-void
-defvar_per_buffer (namestring, address, type, doc)
- char *namestring;
- Lisp_Object *address;
- Lisp_Object type;
- char *doc;
-{
- Lisp_Object sym, val;
- int offset;
-
- sym = intern (namestring);
- val = allocate_misc ();
- offset = (char *)address - (char *)current_buffer;
-
- XMISCTYPE (val) = Lisp_Misc_Buffer_Objfwd;
- XBUFFER_OBJFWD (val)->offset = offset;
- 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 ();
-}
-
-
/* Similar but define a variable whose value is the Lisp Object stored
at a particular offset in the current kboard object. */
Vload_path = Fcons (tem, Vload_path);
}
- /* Add site-list under the installation dir, if it exists. */
+ /* Add site-lisp under the installation dir, if it exists. */
tem = Fexpand_file_name (build_string ("site-lisp"),
Vinstallation_directory);
tem1 = Ffile_exists_p (tem);
/* NORMAL refers to the lisp dir in the source directory. */
/* We used to add ../lisp at the front here, but
that caused trouble because it was copied from dump_path
- into Vload_path, aboe, when Vinstallation_directory was non-nil.
+ into Vload_path, above, when Vinstallation_directory was non-nil.
It should be unnecessary. */
Vload_path = decode_env_path (0, normal);
dump_path = Vload_path;
}
/* Print a warning, using format string FORMAT, that directory DIRNAME
- does not exist. Print it on stderr and put it in *Message*. */
+ does not exist. Print it on stderr and put it in *Messages*. */
void
dir_warning (format, dirname)
in order to do so. However, if you want to customize which suffixes
the loading functions recognize as compression suffixes, you should
customize `jka-compr-load-suffixes' rather than the present variable. */);
- /* We don't use empty_string because it's not initialized yet. */
- Vload_file_rep_suffixes = Fcons (build_string (""), Qnil);
+ Vload_file_rep_suffixes = Fcons (empty_unibyte_string, Qnil);
DEFVAR_BOOL ("load-in-progress", &load_in_progress,
- doc: /* Non-nil iff inside of `load'. */);
+ doc: /* Non-nil if inside of `load'. */);
DEFVAR_LISP ("after-load-alist", &Vafter_load_alist,
doc: /* An alist of expressions to be evalled when particular files are loaded.
The remaining elements of each list are symbols defined as variables
and cons cells of the form `(provide . FEATURE)', `(require . FEATURE)',
-`(defun . FUNCTION)', `(autoload . SYMBOL)', and `(t . SYMBOL)'.
-An element `(t . SYMBOL)' precedes an entry `(defun . FUNCTION)',
-and means that SYMBOL was an autoload before this file redefined it
-as a function.
+`(defun . FUNCTION)', `(autoload . SYMBOL)', `(defface . SYMBOL)'
+and `(t . SYMBOL)'. An element `(t . SYMBOL)' precedes an entry
+`(defun . FUNCTION)', and means that SYMBOL was an autoload before
+this file redefined it as a function.
During preloading, the file name recorded is relative to the main Lisp
directory. These file names are converted to absolute at startup. */);
doc: /* File name, including directory, of user's initialization file.
If the file loaded had extension `.elc', and the corresponding source file
exists, this variable contains the name of source file, suitable for use
-by functions like `custom-save-all' which edit the init file. */);
+by functions like `custom-save-all' which edit the init file.
+While Emacs loads and evaluates the init file, value is the real name
+of the file, regardless of whether or not it has the `.elc' extension. */);
Vuser_init_file = Qnil;
DEFVAR_LISP ("current-load-list", &Vcurrent_load_list,
doc: /* List of buffers being read from by calls to `eval-buffer' and `eval-region'. */);
Veval_buffer_list = Qnil;
+ DEFVAR_LISP ("old-style-backquotes", &Vold_style_backquotes,
+ doc: /* Set to non-nil when `read' encounters an old-style backquote. */);
+ Vold_style_backquotes = Qnil;
+ Qold_style_backquotes = intern ("old-style-backquotes");
+ staticpro (&Qold_style_backquotes);
+
/* Vsource_directory was initialized in init_lread. */
load_descriptor_list = Qnil;