(print_error_message): Print data of `end-of-file'

[gnu-emacs] / src / lread.c

diff --git a/src/lread.c b/src/lread.c
index 5e373bee9a2a7b13bf12aec1d351bc60abfe3457..c1d4dced48be687000ffe35978bb0f17a9751b4b 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -410,6 +410,11 @@ read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
 {
   register Lisp_Object val, delayed_switch_frame;
 
+#ifdef HAVE_WINDOW_SYSTEM
+  if (display_busy_cursor_p)
+    cancel_busy_cursor ();
+#endif
+  
   delayed_switch_frame = Qnil;
 
   /* Read until we get an acceptable event.  */
@@ -467,6 +472,10 @@ read_filtered_event (no_switch_frame, ascii_required, error_nonascii,
   if (! NILP (delayed_switch_frame))
     unread_switch_frame = delayed_switch_frame;
 
+#ifdef HAVE_WINDOW_SYSTEM
+  if (display_busy_cursor_p)
+    start_busy_cursor ();
+#endif
   return val;
 }
 
@@ -611,11 +620,11 @@ Return t if file exists.")
   /* 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 */
-  int safe_p = 1;
 
   CHECK_STRING (file, 0);
 
@@ -1596,6 +1605,72 @@ read_escape (readcharfun, stringp)
     }
 }
 
+
+/* 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 number, ndigits, invalid_p, c, sign;
+
+  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);
+}
+
+
 /* 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.
@@ -1868,8 +1943,17 @@ read1 (readcharfun, pch, first_in_list)
                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));
@@ -2060,13 +2144,10 @@ read1 (readcharfun, pch, first_in_list)
 
     case '.':
       {
-       /* 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'))
+       if (next_char <= 040)
          {
            *pch = c;
            return Qnil;
@@ -2262,7 +2343,7 @@ substitute_object_recurse (object, placeholder, subtree)
     case Lisp_Vectorlike:
       {
        int i;
-       int length = Flength(subtree);
+       int length = XINT (Flength(subtree));
        for (i = 0; i < length; i++)
          {
            Lisp_Object idx = make_number (i);
@@ -3085,9 +3166,10 @@ defvar_per_buffer (namestring, address, type, doc)
   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)
+  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 ();
@@ -3358,7 +3440,8 @@ 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)'.");
+or variables, and cons cells `(provide . FEATURE)', `(require . FEATURE)',\n\
+and `(autoload . SYMBOL)'.");
   Vload_history = Qnil;
 
   DEFVAR_LISP ("load-file-name", &Vload_file_name,
@@ -3396,9 +3479,9 @@ 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.");
+     "Non-nil means `read' converts strings to unibyte whenever possible.\n\
+This is normally bound by `load' and `eval-buffer' to control `read',\n\
+and is not meant for users to change.");
   load_convert_to_unibyte = 0;
 
   DEFVAR_LISP ("source-directory", &Vsource_directory,