/* Lisp parsing and input streams.
-Copyright (C) 1985-1989, 1993-1995, 1997-2011 Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993-1995, 1997-2012 Free Software Foundation, Inc.
This file is part of GNU Emacs.
static int read_pure;
/* For use within read-from-string (this reader is non-reentrant!!) */
-static EMACS_INT read_from_string_index;
-static EMACS_INT read_from_string_index_byte;
-static EMACS_INT read_from_string_limit;
+static ptrdiff_t read_from_string_index;
+static ptrdiff_t read_from_string_index_byte;
+static ptrdiff_t read_from_string_limit;
/* Number of characters read in the current call to Fread or
Fread_from_string. */
{
register struct buffer *inbuffer = XBUFFER (readcharfun);
- EMACS_INT pt_byte = BUF_PT_BYTE (inbuffer);
+ ptrdiff_t pt_byte = BUF_PT_BYTE (inbuffer);
if (pt_byte >= BUF_ZV_BYTE (inbuffer))
return -1;
{
register struct buffer *inbuffer = XMARKER (readcharfun)->buffer;
- EMACS_INT bytepos = marker_byte_position (readcharfun);
+ ptrdiff_t bytepos = marker_byte_position (readcharfun);
if (bytepos >= BUF_ZV_BYTE (inbuffer))
return -1;
else if (BUFFERP (readcharfun))
{
struct buffer *b = XBUFFER (readcharfun);
- EMACS_INT charpos = BUF_PT (b);
- EMACS_INT bytepos = BUF_PT_BYTE (b);
+ ptrdiff_t charpos = BUF_PT (b);
+ ptrdiff_t bytepos = BUF_PT_BYTE (b);
if (! NILP (BVAR (b, enable_multibyte_characters)))
BUF_DEC_POS (b, bytepos);
else if (MARKERP (readcharfun))
{
struct buffer *b = XMARKER (readcharfun)->buffer;
- EMACS_INT bytepos = XMARKER (readcharfun)->bytepos;
+ ptrdiff_t bytepos = XMARKER (readcharfun)->bytepos;
XMARKER (readcharfun)->charpos--;
if (! NILP (BVAR (b, enable_multibyte_characters)))
int sec, usec;
double duration = extract_float (seconds);
- sec = (int) duration;
- usec = (duration - sec) * 1000000;
+ if (0 < duration)
+ duration_to_sec_usec (duration, &sec, &usec);
+ else
+ sec = usec = 0;
+
EMACS_GET_TIME (end_time);
EMACS_SET_SECS_USECS (wait_time, sec, usec);
EMACS_ADD_TIME (end_time, end_time, wait_time);
{
register FILE *stream;
register int fd = -1;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object found, efound, hist_file_name;
/* 1 means we printed the ".el is newer" message. */
handler = Ffind_file_name_handler (found, Qload);
if (! NILP (handler))
return call5 (handler, Qload, found, noerror, nomessage, Qt);
+#ifdef DOS_NT
+ /* Tramp has to deal with semi-broken packages that prepend
+ drive letters to remote files. For that reason, Tramp
+ catches file operations that test for file existence, which
+ makes openp think X:/foo.elc files are remote. However,
+ Tramp does not catch `load' operations for such files, so we
+ end up with a nil as the `load' handler above. If we would
+ continue with fd = -2, we will behave wrongly, and in
+ particular try reading a .elc file in the "rt" mode instead
+ of "rb". See bug #9311 for the results. To work around
+ this, we try to open the file locally, and go with that if it
+ succeeds. */
+ fd = emacs_open (SSDATA (ENCODE_FILE (found)), O_RDONLY, 0);
+ if (fd == -1)
+ fd = -2;
+#endif
}
/* Check if we're stuck in a recursive load cycle.
GCPRO3 (file, found, hist_file_name);
#ifdef WINDOWSNT
- emacs_close (fd);
efound = ENCODE_FILE (found);
- stream = fopen (SSDATA (efound), fmode);
+ /* If we somehow got here with fd == -2, meaning the file is deemed
+ to be remote, don't even try to reopen the file locally; just
+ force a failure instead. */
+ if (fd >= 0)
+ {
+ emacs_close (fd);
+ stream = fopen (SSDATA (efound), fmode);
+ }
+ else
+ stream = NULL;
#else /* not WINDOWSNT */
stream = fdopen (fd, fmode);
#endif /* not WINDOWSNT */
}
if (! NILP (Vpurify_flag))
- Vpreloaded_file_list = Fcons (Fpurecopy(file), Vpreloaded_file_list);
+ Vpreloaded_file_list = Fcons (Fpurecopy (file), Vpreloaded_file_list);
if (NILP (nomessage) || force_load_messages)
{
openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *storeptr, Lisp_Object predicate)
{
register int fd;
- EMACS_INT fn_size = 100;
+ ptrdiff_t fn_size = 100;
char buf[100];
register char *fn = buf;
int absolute = 0;
- EMACS_INT want_length;
+ ptrdiff_t want_length;
Lisp_Object filename;
struct stat st;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
Lisp_Object string, tail, encoded_fn;
- EMACS_INT max_suffix_len = 0;
+ ptrdiff_t max_suffix_len = 0;
CHECK_STRING (str);
{
/* Check that we can access or open it. */
if (NATNUMP (predicate))
- fd = (access (pfn, XFASTINT (predicate)) == 0) ? 1 : -1;
+ fd = (((XFASTINT (predicate) & ~INT_MAX) == 0
+ && access (pfn, XFASTINT (predicate)) == 0)
+ ? 1 : -1);
else
fd = emacs_open (pfn, O_RDONLY, 0);
{
register int c;
register Lisp_Object val;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
struct buffer *b = 0;
int continue_reading_p;
continue_reading_p = 1;
while (continue_reading_p)
{
- int count1 = SPECPDL_INDEX ();
+ ptrdiff_t count1 = SPECPDL_INDEX ();
if (b != 0 && NILP (BVAR (b, name)))
error ("Reading from killed buffer");
/* Ignore whitespace here, so we can detect eof. */
if (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r'
- || c == 0x8a0) /* NBSP */
+ || c == 0xa0) /* NBSP */
goto read_next;
if (!NILP (Vpurify_flag) && c == '(')
This function preserves the position of point. */)
(Lisp_Object buffer, Lisp_Object printflag, Lisp_Object filename, Lisp_Object unibyte, Lisp_Object do_allow_print)
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object tem, buf;
if (NILP (buffer))
This function does not move point. */)
(Lisp_Object start, Lisp_Object end, Lisp_Object printflag, Lisp_Object read_function)
{
- /* FIXME: Do the eval-sexp-add-defvars danse! */
- int count = SPECPDL_INDEX ();
+ /* FIXME: Do the eval-sexp-add-defvars dance! */
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object tem, cbuf;
cbuf = Fcurrent_buffer ();
DEFUN ("read-from-string", Fread_from_string, Sread_from_string, 1, 3, 0,
doc: /* Read one Lisp expression which is represented as text by STRING.
Returns a cons: (OBJECT-READ . FINAL-STRING-INDEX).
+FINAL-STRING-INDEX is an integer giving the position of the next
+ remaining character in STRING.
START and END optionally delimit a substring of STRING from which to read;
they default to 0 and (length STRING) respectively. */)
(Lisp_Object string, Lisp_Object start, Lisp_Object end)
if (STRINGP (stream)
|| ((CONSP (stream) && STRINGP (XCAR (stream)))))
{
- EMACS_INT startval, endval;
+ ptrdiff_t startval, endval;
Lisp_Object string;
if (STRINGP (stream))
else
{
CHECK_NUMBER (end);
- endval = XINT (end);
- if (endval < 0 || endval > SCHARS (string))
+ if (! (0 <= XINT (end) && XINT (end) <= SCHARS (string)))
args_out_of_range (string, end);
+ endval = XINT (end);
}
if (NILP (start))
else
{
CHECK_NUMBER (start);
- startval = XINT (start);
- if (startval < 0 || startval > endval)
+ if (! (0 <= XINT (start) && XINT (start) <= endval))
args_out_of_range (string, start);
+ startval = XINT (start);
}
read_from_string_index = startval;
read_from_string_index_byte = string_char_to_byte (string, startval);
case 'x':
/* A hex escape, as in ANSI C. */
{
- int i = 0;
+ unsigned int i = 0;
int count = 0;
while (1)
{
UNREAD (c);
break;
}
- if (MAX_CHAR < i)
+ /* Allow hex escapes as large as ?\xfffffff, because some
+ packages use them to denote characters with modifiers. */
+ if ((CHAR_META | (CHAR_META - 1)) < i)
error ("Hex character out of range: \\x%x...", i);
count += count < 3;
}
if (c == '[')
{
Lisp_Object tmp;
- EMACS_INT depth, size;
+ int depth;
+ ptrdiff_t size;
tmp = read_vector (readcharfun, 0);
- if (!INTEGERP (AREF (tmp, 0)))
+ size = ASIZE (tmp);
+ if (size == 0)
+ error ("Invalid size char-table");
+ if (! RANGED_INTEGERP (1, AREF (tmp, 0), 3))
error ("Invalid depth in char-table");
depth = XINT (AREF (tmp, 0));
- if (depth < 1 || depth > 3)
- error ("Invalid depth in char-table");
- size = ASIZE (tmp) - 2;
- if (chartab_size [depth] != size)
+ if (chartab_size[depth] != size - 2)
error ("Invalid size char-table");
XSETPVECTYPE (XVECTOR (tmp), PVEC_SUB_CHAR_TABLE);
return tmp;
uninterned_symbol = 1;
c = READCHAR;
if (!(c > 040
- && c != 0x8a0
+ && c != 0xa0 /* NBSP */
&& (c >= 0200
|| strchr ("\"';()[]#`,", c) == NULL)))
{
So we now use the same heuristic as for backquote: old-style
unquotes are only recognized when first on a list, and when
followed by a space.
- Because it's more difficult to peak 2 chars ahead, a new-style
+ Because it's more difficult to peek 2 chars ahead, a new-style
,@ can still not be used outside of a `, unless it's in the middle
of a list. */
if (new_backquote_flag
default:
default_label:
if (c <= 040) goto retry;
- if (c == 0x8a0) /* NBSP */
+ if (c == 0xa0) /* NBSP */
goto retry;
read_symbol:
c = READCHAR;
}
while (c > 040
- && c != 0x8a0 /* NBSP */
+ && c != 0xa0 /* NBSP */
&& (c >= 0200
|| strchr ("\"';()[]#`,", c) == NULL));
}
{
Lisp_Object name, result;
- EMACS_INT nbytes = p - read_buffer;
- EMACS_INT nchars
+ ptrdiff_t nbytes = p - read_buffer;
+ ptrdiff_t nchars
= (multibyte
? multibyte_chars_in_text ((unsigned char *) read_buffer,
nbytes)
if (uninterned_symbol && ! NILP (Vpurify_flag))
name = make_pure_string (read_buffer, nchars, nbytes, multibyte);
else
- name = make_specified_string (read_buffer, nchars, nbytes,multibyte);
+ name = make_specified_string (read_buffer, nchars, nbytes, multibyte);
result = (uninterned_symbol ? Fmake_symbol (name)
: Fintern (name, Qnil));
Also store the bucket number in oblookup_last_bucket_number. */
Lisp_Object
-oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_INT size_byte)
+oblookup (Lisp_Object obarray, register const char *ptr, ptrdiff_t size, ptrdiff_t size_byte)
{
size_t hash;
size_t obsize;
Qnil = intern_c_string ("nil");
/* Fmake_symbol inits fields of new symbols with Qunbound and Qnil,
- so those two need to be fixed manally. */
+ so those two need to be fixed manually. */
SET_SYMBOL_VAL (XSYMBOL (Qunbound), Qunbound);
XSYMBOL (Qunbound)->function = Qunbound;
XSYMBOL (Qunbound)->plist = Qnil;
const char *normal;
int turn_off_warning = 0;
- /* Compute the default load-path. */
+ /* Compute the default Vload-path, with the following logic:
+ If CANNOT_DUMP just use PATH_LOADSEARCH.
+ Else if purify-flag (ie dumping) start from PATH_DUMPLOADSEARCH;
+ otherwise start from PATH_LOADSEARCH.
+ If !initialized, then just set both Vload_path and dump_path.
+ If initialized, then if Vload_path != dump_path, do nothing.
+ (Presumably the load-path has already been changed by something.)
+ Also do nothing if Vinstallation_directory is nil.
+ Otherwise:
+ Remove site-lisp directories from the front of load-path.
+ Add installation-dir/lisp (if exists and not already a member),
+ at the front, and turn off warnings about missing directories
+ (because we are presumably running uninstalled).
+ If it does not exist, add dump_path at the end instead.
+ Add installation-dir/leim (if exists and not already a member)
+ at the front.
+ Add installation-dir/site-lisp (if !no_site_lisp, and exists
+ and not already a member) at the front.
+ If installation-dir != source-dir (ie running an uninstalled,
+ out-of-tree build) AND install-dir/src/Makefile exists BUT
+ install-dir/src/Makefile.in does NOT exist (this is a sanity
+ check), then repeat the above steps for source-dir/lisp,
+ leim and site-lisp.
+ Finally, add the previously removed site-lisp directories back
+ at the front (if !no_site_lisp).
+
+ We then warn about any of the load-path elements that do not
+ exist. The only ones that might not exist are those from
+ PATH_LOADSEARCH, and perhaps dump_path.
+
+ Having done all this, we then throw it all away if purify-flag is
+ nil (ie, not dumping) and EMACSLOADPATH is set, and just
+ unconditionally use the latter value instead.
+ So AFAICS the only net results of all the previous steps will be
+ possibly to issue some irrelevant warnings.
+
+ FIXME? There's a case for saying that if we are running
+ uninstalled, the eventual installation directories should not yet
+ be included in load-path.
+ */
#ifdef CANNOT_DUMP
normal = PATH_LOADSEARCH;
Vload_path = decode_env_path (0, normal);
else
normal = PATH_DUMPLOADSEARCH;
- /* In a dumped Emacs, we normally have to reset the value of
- Vload_path from PATH_LOADSEARCH, since the value that was dumped
- uses ../lisp, instead of the path of the installed elisp
- libraries. However, if it appears that Vload_path was changed
- from the default before dumping, don't override that value. */
+ /* In a dumped Emacs, we normally reset the value of Vload_path using
+ PATH_LOADSEARCH, since the value that was dumped uses lisp/ in
+ the source directory, instead of the path of the installed elisp
+ libraries. However, if it appears that Vload_path has already been
+ changed from the default that was saved before dumping, don't
+ change it further. */
if (initialized)
{
if (! NILP (Fequal (dump_path, Vload_path)))
{
Vload_path = decode_env_path (0, normal);
- if (!NILP (Vinstallation_directory))
+ if (no_site_lisp || !NILP (Vinstallation_directory))
{
Lisp_Object tem, tem1, sitelisp;
- /* Remove site-lisp dirs from path temporarily and store
- them in sitelisp, then conc them on at the end so
- they're always first in path. */
+ /* Remove "site-lisp" dirs from front of path temporarily
+ and store them in sitelisp, then conc them on at the
+ end so they're always first in path.
+ Note that this won't work if you used a
+ --enable-locallisppath element that does not happen
+ to contain "site-lisp" in its name.
+ */
sitelisp = Qnil;
while (1)
{
break;
}
- /* Add to the path the lisp subdir of the
- installation dir, if it exists. */
- tem = Fexpand_file_name (build_string ("lisp"),
- Vinstallation_directory);
- tem1 = Ffile_exists_p (tem);
- if (!NILP (tem1))
+ if (!NILP (Vinstallation_directory))
{
- if (NILP (Fmember (tem, Vload_path)))
+ /* Add to the path the lisp subdir of the
+ installation dir, if it exists. */
+ tem = Fexpand_file_name (build_string ("lisp"),
+ Vinstallation_directory);
+ tem1 = Ffile_exists_p (tem);
+ if (!NILP (tem1))
{
- turn_off_warning = 1;
- Vload_path = Fcons (tem, Vload_path);
+ if (NILP (Fmember (tem, Vload_path)))
+ {
+ turn_off_warning = 1;
+ Vload_path = Fcons (tem, Vload_path);
+ }
}
- }
- else
- /* That dir doesn't exist, so add the build-time
- Lisp dirs instead. */
- Vload_path = nconc2 (Vload_path, dump_path);
-
- /* Add leim under the installation dir, if it exists. */
- tem = Fexpand_file_name (build_string ("leim"),
- Vinstallation_directory);
- tem1 = Ffile_exists_p (tem);
- if (!NILP (tem1))
- {
- if (NILP (Fmember (tem, Vload_path)))
- Vload_path = Fcons (tem, Vload_path);
- }
-
- /* 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);
- if (!NILP (tem1))
- {
- if (NILP (Fmember (tem, Vload_path)))
- Vload_path = Fcons (tem, Vload_path);
- }
-
- /* If Emacs was not built in the source directory,
- and it is run from where it was built, add to load-path
- the lisp, leim and site-lisp dirs under that directory. */
-
- if (NILP (Fequal (Vinstallation_directory, Vsource_directory)))
- {
- Lisp_Object tem2;
+ else
+ /* That dir doesn't exist, so add the build-time
+ Lisp dirs instead. */
+ Vload_path = nconc2 (Vload_path, dump_path);
- tem = Fexpand_file_name (build_string ("src/Makefile"),
+ /* Add leim under the installation dir, if it exists. */
+ tem = Fexpand_file_name (build_string ("leim"),
Vinstallation_directory);
tem1 = Ffile_exists_p (tem);
-
- /* Don't be fooled if they moved the entire source tree
- AFTER dumping Emacs. If the build directory is indeed
- different from the source dir, src/Makefile.in and
- src/Makefile will not be found together. */
- tem = Fexpand_file_name (build_string ("src/Makefile.in"),
- Vinstallation_directory);
- tem2 = Ffile_exists_p (tem);
- if (!NILP (tem1) && NILP (tem2))
+ if (!NILP (tem1))
{
- tem = Fexpand_file_name (build_string ("lisp"),
- Vsource_directory);
-
if (NILP (Fmember (tem, Vload_path)))
Vload_path = Fcons (tem, Vload_path);
+ }
- tem = Fexpand_file_name (build_string ("leim"),
- Vsource_directory);
+ /* Add site-lisp under the installation dir, if it exists. */
+ if (!no_site_lisp)
+ {
+ tem = Fexpand_file_name (build_string ("site-lisp"),
+ Vinstallation_directory);
+ tem1 = Ffile_exists_p (tem);
+ if (!NILP (tem1))
+ {
+ if (NILP (Fmember (tem, Vload_path)))
+ Vload_path = Fcons (tem, Vload_path);
+ }
+ }
- if (NILP (Fmember (tem, Vload_path)))
- Vload_path = Fcons (tem, Vload_path);
+ /* If Emacs was not built in the source directory,
+ and it is run from where it was built, add to load-path
+ the lisp, leim and site-lisp dirs under that directory. */
- tem = Fexpand_file_name (build_string ("site-lisp"),
- Vsource_directory);
+ if (NILP (Fequal (Vinstallation_directory, Vsource_directory)))
+ {
+ Lisp_Object tem2;
+
+ tem = Fexpand_file_name (build_string ("src/Makefile"),
+ Vinstallation_directory);
+ tem1 = Ffile_exists_p (tem);
+
+ /* Don't be fooled if they moved the entire source tree
+ AFTER dumping Emacs. If the build directory is indeed
+ different from the source dir, src/Makefile.in and
+ src/Makefile will not be found together. */
+ tem = Fexpand_file_name (build_string ("src/Makefile.in"),
+ Vinstallation_directory);
+ tem2 = Ffile_exists_p (tem);
+ if (!NILP (tem1) && NILP (tem2))
+ {
+ tem = Fexpand_file_name (build_string ("lisp"),
+ Vsource_directory);
- if (NILP (Fmember (tem, Vload_path)))
- Vload_path = Fcons (tem, Vload_path);
- }
- }
+ if (NILP (Fmember (tem, Vload_path)))
+ Vload_path = Fcons (tem, Vload_path);
+
+ tem = Fexpand_file_name (build_string ("leim"),
+ Vsource_directory);
+
+ if (NILP (Fmember (tem, Vload_path)))
+ Vload_path = Fcons (tem, Vload_path);
+
+ if (!no_site_lisp)
+ {
+ tem = Fexpand_file_name (build_string ("site-lisp"),
+ Vsource_directory);
+
+ if (NILP (Fmember (tem, Vload_path)))
+ Vload_path = Fcons (tem, Vload_path);
+ }
+ }
+ } /* Vinstallation_directory != Vsource_directory */
+ } /* if Vinstallation_directory */
if (!NILP (sitelisp) && !no_site_lisp)
Vload_path = nconc2 (Fnreverse (sitelisp), Vload_path);
- }
- }
+ } /* if Vinstallation_directory || no_site_lisp */
+ } /* if dump_path == Vload_path */
}
- else
+ else /* !initialized */
{
/* NORMAL refers to the lisp dir in the source directory. */
/* We used to add ../lisp at the front here, but
Vload_path = decode_env_path (0, normal);
dump_path = Vload_path;
}
-#endif
+#endif /* CANNOT_DUMP */
#if (!(defined (WINDOWSNT) || (defined (HAVE_NS))))
/* When Emacs is invoked over network shares on NT, PATH_LOADSEARCH is
confuses users. Since PATH_LOADSEARCH is always overridden by the
EMACSLOADPATH environment variable below, disable the warning on NT. */
+ /* HAVE_NS also uses EMACSLOADPATH. */
+
/* Warn if dirs in the *standard* path don't exist. */
if (!turn_off_warning)
{
if (STRINGP (dirfile))
{
dirfile = Fdirectory_file_name (dirfile);
+ /* Do we really need to warn about missing site-lisp dirs?
+ It's true that the installation should have created
+ them and added subdirs.el, but it's harmless if they
+ are not there. */
if (access (SSDATA (dirfile), 0) < 0)
dir_warning ("Warning: Lisp directory `%s' does not exist.\n",
XCAR (path_tail));
void
dir_warning (const char *format, Lisp_Object dirname)
{
- char *buffer
- = (char *) alloca (SCHARS (dirname) + strlen (format) + 5);
-
fprintf (stderr, format, SDATA (dirname));
- sprintf (buffer, format, SDATA (dirname));
+
/* Don't log the warning before we've initialized!! */
if (initialized)
- message_dolog (buffer, strlen (buffer), 0, STRING_MULTIBYTE (dirname));
+ {
+ char *buffer;
+ ptrdiff_t message_len;
+ USE_SAFE_ALLOCA;
+ SAFE_ALLOCA (buffer, char *,
+ SBYTES (dirname) + strlen (format) - (sizeof "%s" - 1) + 1);
+ message_len = esprintf (buffer, format, SDATA (dirname));
+ message_dolog (buffer, message_len, 0, STRING_MULTIBYTE (dirname));
+ SAFE_FREE ();
+ }
}
void
Non-nil means that the code in the current buffer should be evaluated
with lexical binding.
This variable is automatically set from the file variables of an
-interpreted Lisp file read using `load'. */);
+interpreted Lisp file read using `load'. Unlike other file local
+variables, this must be set in the first line of a file. */);
Fmake_variable_buffer_local (Qlexical_binding);
DEFVAR_LISP ("eval-buffer-list", Veval_buffer_list,