comparison src/lread.c @ 9274:5c66d8b65a7c

(Fget_file_char, Fload, read1, oblookup, map_obarray, defsubr, defalias, defvar_int, defvar_bool, defvar_lisp, defvar_lisp_nopro, defvar_per_buffer): Use new accessor macros instead of calling XSET directly.

9273:129621997564

DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
  "Don't use this yourself.")
  ()
{
  register Lisp_Object val;
  XSET (val, Lisp_Int, getc (instream));
  return val;
}

static void readevalloop ();
static Lisp_Object load_unwind ();

  /* We may not be able to store STREAM itself as a Lisp_Object pointer
     since that is guaranteed to work only for data that has been malloc'd.
     So malloc a full-size pointer, and record the address of that pointer.  */
  ptr = (FILE **) xmalloc (sizeof (FILE *));
  *ptr = stream;
  XSET (lispstream, Lisp_Internal_Stream, (EMACS_INT) ptr);
  record_unwind_protect (load_unwind, lispstream);
  record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
  load_descriptor_list
    = Fcons (make_number (fileno (stream)), load_descriptor_list);
  load_in_progress++;

    case ')':
    case ']':
      {
	register Lisp_Object val;
	XSET (val, Lisp_Internal, c);
	return val;
      }

    case '#':
      c = READCHAR;

	c = READCHAR;
	if (c < 0) return Fsignal (Qend_of_file, Qnil);

	if (c == '\\')
	  XSET (val, Lisp_Int, read_escape (readcharfun));
	else
	  XSET (val, Lisp_Int, c);

	return val;
      }

    case '\"':

	if (! isdigit (next_char))
#endif
	  {
	    register Lisp_Object val;
	    XSET (val, Lisp_Internal, c);
	    return val;
	  }

	/* Otherwise, we fall through!  Note that the atom-reading loop
	   below will now loop at least once, assuring that we will not

		  {
#ifdef LISP_FLOAT_TYPE
		    if (p1[-1] == '.')
		      p1[-1] = '\0';
#endif
		    XSET (val, Lisp_Int, atoi (read_buffer));
		    return val;
		  }
	      }
#ifdef LISP_FLOAT_TYPE
	    if (isfloat_string (read_buffer))

  bucket = XVECTOR (obarray)->contents[hash];
  if (XFASTINT (bucket) == 0)
    ;
  else if (!SYMBOLP (bucket))
    error ("Bad data in guts of obarray"); /* Like CADR error message */
  else for (tail = bucket; ; XSET (tail, Lisp_Symbol, XSYMBOL (tail)->next))
      {
	if (XSYMBOL (tail)->name->size == size &&
	    !bcmp (XSYMBOL (tail)->name->data, ptr, size))
	  return tail;
	else if (XSYMBOL (tail)->next == 0)
	  break;
      }
  XSET (tem, Lisp_Int, hash);
  return tem;
}

static int
hash_string (ptr, len)

	while (1)
	  {
	    (*fn) (tail, arg);
	    if (XSYMBOL (tail)->next == 0)
	      break;
	    XSET (tail, Lisp_Symbol, XSYMBOL (tail)->next);
	  }
    }
}

mapatoms_1 (sym, function)

defsubr (sname)
     struct Lisp_Subr *sname;
{
  Lisp_Object sym;
  sym = intern (sname->symbol_name);
  XSET (XSYMBOL (sym)->function, Lisp_Subr, sname);
}

#ifdef NOTDEF /* use fset in subr.el now */
void
defalias (sname, string)
     struct Lisp_Subr *sname;
     char *string;
{
  Lisp_Object sym;
  sym = intern (string);
  XSET (XSYMBOL (sym)->function, Lisp_Subr, sname);
}
#endif /* NOTDEF */

/* Define an "integer variable"; a symbol whose value is forwarded
 to a C variable of type int.  Sample call: */

     char *namestring;
     int *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSET (XSYMBOL (sym)->value, Lisp_Intfwd, address);
}

/* Similar but define a variable whose value is T if address contains 1,
 NIL if address contains 0 */

     char *namestring;
     int *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSET (XSYMBOL (sym)->value, Lisp_Boolfwd, address);
}

/* Similar but define a variable whose value is the Lisp Object stored at address. */

void

     char *namestring;
     Lisp_Object *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSET (XSYMBOL (sym)->value, Lisp_Objfwd, address);
  staticpro (address);
}

/* Similar but don't request gc-marking of the C variable.
   Used when that variable will be gc-marked for some other reason,

     char *namestring;
     Lisp_Object *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSET (XSYMBOL (sym)->value, Lisp_Objfwd, address);
}

#ifndef standalone

/* Similar but define a variable whose value is the Lisp Object stored in

  extern struct buffer buffer_local_symbols;

  sym = intern (namestring);
  offset = (char *)address - (char *)current_buffer;

  XSET (XSYMBOL (sym)->value, Lisp_Buffer_Objfwd,
	(Lisp_Object *) offset);
  *(Lisp_Object *)(offset + (char *)&buffer_local_symbols) = sym;
  *(Lisp_Object *)(offset + (char *)&buffer_local_types) = type;
  if (*(int *)(offset + (char *)&buffer_local_flags) == 0)
    /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
       slot of buffer_local_flags */

9274:5c66d8b65a7c

DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
  "Don't use this yourself.")
  ()
{
  register Lisp_Object val;
  XSETINT (val, getc (instream));
  return val;
}

static void readevalloop ();
static Lisp_Object load_unwind ();

  /* We may not be able to store STREAM itself as a Lisp_Object pointer
     since that is guaranteed to work only for data that has been malloc'd.
     So malloc a full-size pointer, and record the address of that pointer.  */
  ptr = (FILE **) xmalloc (sizeof (FILE *));
  *ptr = stream;
  XSETINTERNAL_STREAM (lispstream, (EMACS_INT) ptr);
  record_unwind_protect (load_unwind, lispstream);
  record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
  load_descriptor_list
    = Fcons (make_number (fileno (stream)), load_descriptor_list);
  load_in_progress++;

    case ')':
    case ']':
      {
	register Lisp_Object val;
	XSETINTERNAL (val, c);
	return val;
      }

    case '#':
      c = READCHAR;

	c = READCHAR;
	if (c < 0) return Fsignal (Qend_of_file, Qnil);

	if (c == '\\')
	  XSETINT (val, read_escape (readcharfun));
	else
	  XSETINT (val, c);

	return val;
      }

    case '\"':

	if (! isdigit (next_char))
#endif
	  {
	    register Lisp_Object val;
	    XSETINTERNAL (val, c);
	    return val;
	  }

	/* Otherwise, we fall through!  Note that the atom-reading loop
	   below will now loop at least once, assuring that we will not

		  {
#ifdef LISP_FLOAT_TYPE
		    if (p1[-1] == '.')
		      p1[-1] = '\0';
#endif
		    XSETINT (val, atoi (read_buffer));
		    return val;
		  }
	      }
#ifdef LISP_FLOAT_TYPE
	    if (isfloat_string (read_buffer))

  bucket = XVECTOR (obarray)->contents[hash];
  if (XFASTINT (bucket) == 0)
    ;
  else if (!SYMBOLP (bucket))
    error ("Bad data in guts of obarray"); /* Like CADR error message */
  else for (tail = bucket; ; XSETSYMBOL (tail, XSYMBOL (tail)->next))
      {
	if (XSYMBOL (tail)->name->size == size &&
	    !bcmp (XSYMBOL (tail)->name->data, ptr, size))
	  return tail;
	else if (XSYMBOL (tail)->next == 0)
	  break;
      }
  XSETINT (tem, hash);
  return tem;
}

static int
hash_string (ptr, len)

	while (1)
	  {
	    (*fn) (tail, arg);
	    if (XSYMBOL (tail)->next == 0)
	      break;
	    XSETSYMBOL (tail, XSYMBOL (tail)->next);
	  }
    }
}

mapatoms_1 (sym, function)

defsubr (sname)
     struct Lisp_Subr *sname;
{
  Lisp_Object sym;
  sym = intern (sname->symbol_name);
  XSETSUBR (XSYMBOL (sym)->function, sname);
}

#ifdef NOTDEF /* use fset in subr.el now */
void
defalias (sname, string)
     struct Lisp_Subr *sname;
     char *string;
{
  Lisp_Object sym;
  sym = intern (string);
  XSETSUBR (XSYMBOL (sym)->function, sname);
}
#endif /* NOTDEF */

/* Define an "integer variable"; a symbol whose value is forwarded
 to a C variable of type int.  Sample call: */

     char *namestring;
     int *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSETINTFWD (XSYMBOL (sym)->value, address);
}

/* Similar but define a variable whose value is T if address contains 1,
 NIL if address contains 0 */

     char *namestring;
     int *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSETBOOLFWD (XSYMBOL (sym)->value, address);
}

/* Similar but define a variable whose value is the Lisp Object stored at address. */

void

     char *namestring;
     Lisp_Object *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSETOBJFWD (XSYMBOL (sym)->value, address);
  staticpro (address);
}

/* Similar but don't request gc-marking of the C variable.
   Used when that variable will be gc-marked for some other reason,

     char *namestring;
     Lisp_Object *address;
{
  Lisp_Object sym;
  sym = intern (namestring);
  XSETOBJFWD (XSYMBOL (sym)->value, address);
}

#ifndef standalone

/* Similar but define a variable whose value is the Lisp Object stored in

  extern struct buffer buffer_local_symbols;

  sym = intern (namestring);
  offset = (char *)address - (char *)current_buffer;

  XSETBUFFER_OBJFWD (XSYMBOL (sym)->value,
		     (Lisp_Object *) offset);
  *(Lisp_Object *)(offset + (char *)&buffer_local_symbols) = sym;
  *(Lisp_Object *)(offset + (char *)&buffer_local_types) = type;
  if (*(int *)(offset + (char *)&buffer_local_flags) == 0)
    /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
       slot of buffer_local_flags */