C++ NILP函数代码示例

static bool
reread_doc_file (Lisp_Object file)
{
  if (NILP (file))
    Fsnarf_documentation (Vdoc_file_name);
  else
    Fload (file, Qt, Qt, Qt, Qnil);

  return 1;
}

/* Given a selection-name and desired type, this looks up our local copy of
   the selection value and converts it to the type. */
static Lisp_Object
get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type)
{
  Lisp_Object local_value = assq_no_quit (selection_symbol, Vselection_alist);

  if (!NILP (local_value))
    {
      Lisp_Object value_list = XCAR (XCDR (local_value));
      Lisp_Object value;

      /* First try to find an entry of the appropriate type */
      value = assq_no_quit (target_type, value_list);

      if (!NILP (value))
	return XCDR (value);
    }

  return Qnil;
}

static void
record_backtrace (log_t *log, EMACS_INT count)
{
  Lisp_Object backtrace;
  ptrdiff_t index;

  if (!INTEGERP (log->next_free))
    /* FIXME: transfer the evicted counts to a special entry rather
       than dropping them on the floor.  */
    evict_lower_half (log);
  index = XINT (log->next_free);

  /* Get a "working memory" vector.  */
  backtrace = HASH_KEY (log, index);
  get_backtrace (backtrace);

  { /* We basically do a `gethash+puthash' here, except that we have to be
       careful to avoid memory allocation since we're in a signal
       handler, and we optimize the code to try and avoid computing the
       hash+lookup twice.  See fns.c:Fputhash for reference.  */
    EMACS_UINT hash;
    ptrdiff_t j = hash_lookup (log, backtrace, &hash);
    if (j >= 0)
      {
	EMACS_INT old_val = XINT (HASH_VALUE (log, j));
	EMACS_INT new_val = saturated_add (old_val, count);
	set_hash_value_slot (log, j, make_number (new_val));
      }
    else
      { /* BEWARE!  hash_put in general can allocate memory.
	   But currently it only does that if log->next_free is nil.  */
	int j;
	eassert (!NILP (log->next_free));
	j = hash_put (log, backtrace, make_number (count), hash);
	/* Let's make sure we've put `backtrace' right where it
	   already was to start with.  */
	eassert (index == j);

	/* FIXME: If the hash-table is almost full, we should set
	   some global flag so that some Elisp code can offload its
	   data elsewhere, so as to avoid the eviction code.
	   There are 2 ways to do that, AFAICT:
	   - Set a flag checked in QUIT, such that QUIT can then call
	     Fprofiler_cpu_log and stash the full log for later use.
	   - Set a flag check in post-gc-hook, so that Elisp code can call
	     profiler-cpu-log.  That gives us more flexibility since that
	     Elisp code can then do all kinds of fun stuff like write
	     the log to disk.  Or turn it right away into a call tree.
	   Of course, using Elisp is generally preferable, but it may
	   take longer until we get a chance to run the Elisp code, so
	   there's more risk that the table will get full before we
	   get there.  */
      }
  }
}

/* This callback is called when the FD is available for read.  The inotify
   events are read from FD and converted into input_events.  */
static void
inotify_callback (int fd, void *_)
{
  int to_read;
  if (ioctl (fd, FIONREAD, &to_read) < 0)
    report_file_notify_error ("Error while retrieving file system events",
			      Qnil);
  USE_SAFE_ALLOCA;
  char *buffer = SAFE_ALLOCA (to_read);
  ssize_t n = read (fd, buffer, to_read);
  if (n < 0)
    report_file_notify_error ("Error while reading file system events", Qnil);

  struct input_event event;
  EVENT_INIT (event);
  event.kind = FILE_NOTIFY_EVENT;

  for (ssize_t i = 0; i < n; )
    {
      struct inotify_event *ev = (struct inotify_event *) &buffer[i];
      Lisp_Object descriptor = INTEGER_TO_CONS (ev->wd);
      Lisp_Object prevtail = find_descriptor (descriptor);

      if (! NILP (prevtail))
        {
	  Lisp_Object tail = CONSP (prevtail) ? XCDR (prevtail) : watch_list;
	  for (Lisp_Object watches = XCDR (XCAR (tail)); ! NILP (watches);
	       watches = XCDR (watches))
            {
              event.arg = inotifyevent_to_event (XCAR (watches), ev);
              if (!NILP (event.arg))
                kbd_buffer_store_event (&event);
            }
          /* If event was removed automatically: Drop it from watch list.  */
          if (ev->mask & IN_IGNORED)
	    remove_descriptor (prevtail, true);
        }
      i += sizeof (*ev) + ev->len;
    }

  SAFE_FREE ();
}

static int
gtk_get_button_size (struct frame *f, Lisp_Object window,
		     struct toolbar_button *tb, int vert, int pos)
{
  int shadow_thickness = 2;
  int size;

  if (tb->blank)
    {
      if (!NILP (tb->down_glyph))
	size = XINT (tb->down_glyph);
      else
	size = DEFAULT_TOOLBAR_BLANK_SIZE;
    }
  else
    {
      struct window *w = XWINDOW (window);
      Lisp_Object glyph = get_toolbar_button_glyph (w, tb);

      /* Unless, of course, the user has done something stupid like
         change the glyph out from under us.  Use a blank placeholder
         in that case. */
      if (NILP (glyph))
	return XINT (f->toolbar_size[pos]);

      if (vert)
	size = glyph_height (glyph, window);
      else
	size = glyph_width (glyph, window);
    }

  if (!size)
    {
      /* If the glyph doesn't have a size we'll insert a blank
         placeholder instead. */
      return XINT (f->toolbar_size[pos]);
    }

  size += shadow_thickness * 2;

  return (size);
}

static void
ensure_not_printing (struct device *d)
{
  if (!NILP (DEVICE_FRAME_LIST (d)))
  {
    Lisp_Object device = wrap_device (d);

    invalid_operation ("Cannot change settings while print job is active",
		       device);
  }
}

/* For use by abbrev_match(): Match SYMBOL's name against buffer text
   before point, case-insensitively.  When found, return non-zero, so
   that map_obarray terminates mapping.  */
static int abbrev_match_mapper(Lisp_Object symbol, void *arg)
{
	struct abbrev_match_mapper_closure *closure =
	    (struct abbrev_match_mapper_closure *)arg;
	Charcount abbrev_length;
	Lisp_Symbol *sym = XSYMBOL(symbol);
	Lisp_String *abbrev;

	/* symbol_value should be OK here, because abbrevs are not expected
	   to contain any SYMBOL_MAGIC stuff.  */
	if (UNBOUNDP(symbol_value(sym)) || NILP(symbol_value(sym))) {
		/* The symbol value of nil means that abbrev got undefined. */
		return 0;
	}
	abbrev = symbol_name(sym);
	abbrev_length = string_char_length(abbrev);
	if (abbrev_length > closure->maxlen) {
		/* This abbrev is too large -- it wouldn't fit. */
		return 0;
	}
	/* If `bar' is an abbrev, and a user presses `fubar<SPC>', we don't
	   normally want to expand it.  OTOH, if the abbrev begins with
	   non-word syntax (e.g. `#if'), it is OK to abbreviate it anywhere.  */
	if (abbrev_length < closure->maxlen && abbrev_length > 0
	    && (WORD_SYNTAX_P(closure->chartab, string_char(abbrev, 0)))
	    && (WORD_SYNTAX_P(closure->chartab,
			      BUF_FETCH_CHAR(closure->buf,
					     closure->point - (abbrev_length +
							       1))))) {
		return 0;
	}
	/* Match abbreviation string against buffer text.  */
	{
		Bufbyte *ptr = string_data(abbrev);
		Charcount idx;

		for (idx = 0; idx < abbrev_length; idx++) {
			if (DOWNCASE(closure->buf,
				     BUF_FETCH_CHAR(closure->buf,
						    closure->point -
						    abbrev_length + idx))
			    != DOWNCASE(closure->buf, charptr_emchar(ptr))) {
				break;
			}
			INC_CHARPTR(ptr);
		}
		if (idx == abbrev_length) {
			/* This is the one. */
			closure->found = sym;
			return 1;
		}
	}
	return 0;
}

void
save_menu_items (void)
{
  Lisp_Object saved = list4 (!NILP (menu_items_inuse) ? menu_items : Qnil,
			     make_number (menu_items_used),
			     make_number (menu_items_n_panes),
			     make_number (menu_items_submenu_depth));
  record_unwind_protect (restore_menu_items, saved);
  menu_items_inuse = Qnil;
  menu_items = Qnil;
}

struct console *
decode_console (Lisp_Object console)
{
  if (NILP (console))
    console = Fselected_console ();
  /* quietly accept devices and frames for the console arg */
  if (DEVICEP (console) || FRAMEP (console))
    console = DEVICE_CONSOLE (decode_device (console));
  CHECK_LIVE_CONSOLE (console);
  return XCONSOLE (console);
}

void
discard_menu_items (void)
{
  /* Free the structure if it is especially large.
     Otherwise, hold on to it, to save time.  */
  if (menu_items_allocated > 200)
    {
      menu_items = Qnil;
      menu_items_allocated = 0;
    }
  eassert (NILP (menu_items_inuse));
}

static Lisp_Object
gtk_device_to_console_connection (Lisp_Object connection, Error_behavior errb)
{
  /* Strip the trailing .# off of the connection, if it's there. */

  if (NILP (connection))
    return Qnil;
  else
    {
	connection = build_string ("gtk");
    }
  return connection;
}

int find_env(int exp_id) {
  int level = call_depth;
  int found = L_NIL;

  while (level >= 0) {
    found = env[(level << 8) + expression[exp_id]];
    if (!NILP(found)){
      return found;
    }
    level -= 1;
  }
  return L_NIL;
}

T lookup(T name, Environment env) {
	assert(name->type == T_SYM);

	for (; !NILP(env); env=CDR(env)) {
		T binding;
		binding = CAR(env);
		if (CAR(binding) == name) {
			return CDR(binding);
		}
	}

	return NIL;
}

static int
get_logical_cursor_bitmap (struct window *w, Lisp_Object cursor)
{
  Lisp_Object cmap, bm = Qnil;

  if ((cmap = BVAR (XBUFFER (w->buffer), fringe_cursor_alist)), !NILP (cmap))
    {
      bm = Fassq (cursor, cmap);
      if (CONSP (bm))
	{
	  if ((bm = XCDR (bm)), NILP (bm))
	    return NO_FRINGE_BITMAP;
	  return lookup_fringe_bitmap (bm);
	}
    }
  if (EQ (cmap, BVAR (&buffer_defaults, fringe_cursor_alist)))
    return NO_FRINGE_BITMAP;
  bm = Fassq (cursor, BVAR (&buffer_defaults, fringe_cursor_alist));
  if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
    return NO_FRINGE_BITMAP;
  return lookup_fringe_bitmap (bm);
}

static void
restore_menu_items (Lisp_Object saved)
{
  menu_items = XCAR (saved);
  menu_items_inuse = (! NILP (menu_items) ? Qt : Qnil);
  menu_items_allocated = (VECTORP (menu_items) ? ASIZE (menu_items) : 0);
  saved = XCDR (saved);
  menu_items_used = XINT (XCAR (saved));
  saved = XCDR (saved);
  menu_items_n_panes = XINT (XCAR (saved));
  saved = XCDR (saved);
  menu_items_submenu_depth = XINT (XCAR (saved));
}