自学教程：C++ AREF函数代码示例

static voidextract_user_token(struct cparse_params *v, VALUE block_args,                   VALUE *tok, VALUE *val){    if (NIL_P(block_args)) {        /* EOF */        *tok = Qfalse;        *val = rb_str_new("$", 1);        return;    }    if (TYPE(block_args) != T_ARRAY) {        rb_raise(rb_eTypeError,                 "%s() %s %s (must be Array[2])",                 v->lex_is_iterator ? rb_id2name(v->lexmid) : "next_token",                 v->lex_is_iterator ? "yielded" : "returned",                 rb_class2name(CLASS_OF(block_args)));    }    if (RARRAY_LEN(block_args) != 2) {        rb_raise(rb_eArgError,                 "%s() %s wrong size of array (%ld for 2)",                 v->lex_is_iterator ? rb_id2name(v->lexmid) : "next_token",                 v->lex_is_iterator ? "yielded" : "returned",                 RARRAY_LEN(block_args));    }    *tok = AREF(block_args, 0);    *val = AREF(block_args, 1);}

static Lisp_Objectvalidate_coding_system (Lisp_Object coding_system){  Lisp_Object eol_type;  /* Make sure the input is valid. */  if (NILP (Fcoding_system_p (coding_system)))    return Qnil;  /* Make sure we use a DOS coding system as mandated by the system     specs. */  eol_type = Fcoding_system_eol_type (coding_system);  /* Already a DOS coding system? */  if (EQ (eol_type, make_number (1)))    return coding_system;  /* Get EOL_TYPE vector of the base of CODING_SYSTEM.  */  if (!VECTORP (eol_type))    {      eol_type = Fcoding_system_eol_type (Fcoding_system_base (coding_system));      if (!VECTORP (eol_type))	return Qnil;    }  return AREF (eol_type, 1);}

static emacs_valuemodule_vec_get (emacs_env *env, emacs_value vec, ptrdiff_t i){  MODULE_FUNCTION_BEGIN (module_nil);  Lisp_Object lvec = value_to_lisp (vec);  CHECK_VECTOR (lvec);  CHECK_RANGED_INTEGER (make_number (i), 0, ASIZE (lvec) - 1);  return lisp_to_value (AREF (lvec, i));}

static intxftfont_has_char (Lisp_Object font, int c){  struct xftfont_info *xftfont_info;  struct charset *cs = NULL;  if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qja)      && charset_jisx0208 >= 0)    cs = CHARSET_FROM_ID (charset_jisx0208);  else if (EQ (AREF (font, FONT_ADSTYLE_INDEX), Qko)      && charset_ksc5601 >= 0)    cs = CHARSET_FROM_ID (charset_ksc5601);  if (cs)    return (ENCODE_CHAR (cs, c) != CHARSET_INVALID_CODE (cs));  if (FONT_ENTITY_P (font))    return ftfont_driver.has_char (font, c);  xftfont_info = (struct xftfont_info *) XFONT_OBJECT (font);  return (XftCharExists (xftfont_info->display, xftfont_info->xftfont,			 (FcChar32) c) == FcTrue);}

/* As above, but return the menu selection instead of storing in kb buffer.   If KEYMAPS, return full prefixes to selection. */Lisp_Objectfind_and_return_menu_selection (struct frame *f, bool keymaps, void *client_data){  Lisp_Object prefix, entry;  int i;  Lisp_Object *subprefix_stack;  int submenu_depth = 0;  prefix = entry = Qnil;  i = 0;  subprefix_stack = alloca (menu_items_used * word_size);  while (i < menu_items_used)    {      if (EQ (AREF (menu_items, i), Qnil))        {          subprefix_stack[submenu_depth++] = prefix;          prefix = entry;          i++;        }      else if (EQ (AREF (menu_items, i), Qlambda))        {          prefix = subprefix_stack[--submenu_depth];          i++;        }      else if (EQ (AREF (menu_items, i), Qt))        {          prefix            = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);          i += MENU_ITEMS_PANE_LENGTH;        }      /* Ignore a nil in the item list.         It's meaningful only for dialog boxes.  */      else if (EQ (AREF (menu_items, i), Qquote))        i += 1;      else        {          entry            = AREF (menu_items, i + MENU_ITEMS_ITEM_VALUE);          if (aref_addr (menu_items, i) == client_data)            {              if (keymaps)                {                  int j;                  entry = list1 (entry);                  if (!NILP (prefix))                    entry = Fcons (prefix, entry);                  for (j = submenu_depth - 1; j >= 0; j--)                    if (!NILP (subprefix_stack[j]))                      entry = Fcons (subprefix_stack[j], entry);                }              return entry;            }          i += MENU_ITEMS_ITEM_LENGTH;        }    }  return Qnil;}

static voidxftfont_add_rendering_parameters (FcPattern *pat, Lisp_Object entity){  Lisp_Object tail;  int ival;  for (tail = AREF (entity, FONT_EXTRA_INDEX); CONSP (tail); tail = XCDR (tail))    {      Lisp_Object key = XCAR (XCAR (tail));      Lisp_Object val = XCDR (XCAR (tail));      if (EQ (key, QCantialias))          FcPatternAddBool (pat, FC_ANTIALIAS, NILP (val) ? FcFalse : FcTrue);      else if (EQ (key, QChinting))	FcPatternAddBool (pat, FC_HINTING, NILP (val) ? FcFalse : FcTrue);      else if (EQ (key, QCautohint))	FcPatternAddBool (pat, FC_AUTOHINT, NILP (val) ? FcFalse : FcTrue);      else if (EQ (key, QChintstyle))	{	  if (INTEGERP (val))	    FcPatternAddInteger (pat, FC_HINT_STYLE, XINT (val));          else if (SYMBOLP (val)                   && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))	    FcPatternAddInteger (pat, FC_HINT_STYLE, ival);	}      else if (EQ (key, QCrgba))	{	  if (INTEGERP (val))	    FcPatternAddInteger (pat, FC_RGBA, XINT (val));          else if (SYMBOLP (val)                   && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))	    FcPatternAddInteger (pat, FC_RGBA, ival);	}      else if (EQ (key, QClcdfilter))	{	  if (INTEGERP (val))	    FcPatternAddInteger (pat, FC_LCD_FILTER, ival = XINT (val));          else if (SYMBOLP (val)                   && FcNameConstant (SDATA (SYMBOL_NAME (val)), &ival))	    FcPatternAddInteger (pat, FC_LCD_FILTER, ival);	}#ifdef FC_EMBOLDEN      else if (EQ (key, QCembolden))	FcPatternAddBool (pat, FC_EMBOLDEN, NILP (val) ? FcFalse : FcTrue);#endif    }}

static emacs_valuemodule_vec_get (emacs_env *env, emacs_value vec, ptrdiff_t i){  MODULE_FUNCTION_BEGIN (module_nil);  Lisp_Object lvec = value_to_lisp (vec);  if (! VECTORP (lvec))    {      module_wrong_type (env, Qvectorp, lvec);      return module_nil;    }  if (! (0 <= i && i < ASIZE (lvec)))    {      if (MOST_NEGATIVE_FIXNUM <= i && i <= MOST_POSITIVE_FIXNUM)	module_args_out_of_range (env, lvec, make_number (i));      else	module_non_local_exit_signal_1 (env, Qoverflow_error, Qnil);      return module_nil;    }  return lisp_to_value (AREF (lvec, i));}

static Lisp_Objectw32_dialog_show (struct frame *f, Lisp_Object title,		 Lisp_Object header, char **error){  int i, nb_buttons = 0;  char dialog_name[6];  int menu_item_selection;  widget_value *wv, *first_wv = 0, *prev_wv = 0;  /* Number of elements seen so far, before boundary.  */  int left_count = 0;  /* true means we've seen the boundary between left-hand elts and     right-hand.  */  bool boundary_seen = false;  *error = NULL;  if (menu_items_n_panes > 1)    {      *error = "Multiple panes in dialog box";      return Qnil;    }  /* Create a tree of widget_value objects     representing the text label and buttons.  */  {    Lisp_Object pane_name;    char *pane_string;    pane_name = AREF (menu_items, MENU_ITEMS_PANE_NAME);    pane_string = (NILP (pane_name)		   ? "" : SSDATA (pane_name));    prev_wv = make_widget_value ("message", pane_string, true, Qnil);    first_wv = prev_wv;    /* Loop over all panes and items, filling in the tree.  */    i = MENU_ITEMS_PANE_LENGTH;    while (i < menu_items_used)      {	/* Create a new item within current pane.  */	Lisp_Object item_name, enable, descrip, help;	item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);	enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);	descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);        help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);	if (NILP (item_name))	  {	    free_menubar_widget_value_tree (first_wv);	    *error = "Submenu in dialog items";	    return Qnil;	  }	if (EQ (item_name, Qquote))	  {	    /* This is the boundary between left-side elts	       and right-side elts.  Stop incrementing right_count.  */	    boundary_seen = true;	    i++;	    continue;	  }	if (nb_buttons >= 9)	  {	    free_menubar_widget_value_tree (first_wv);	    *error = "Too many dialog items";	    return Qnil;	  }	wv = make_widget_value (button_names[nb_buttons],				SSDATA (item_name),				!NILP (enable), Qnil);	prev_wv->next = wv;	if (!NILP (descrip))	  wv->key = SSDATA (descrip);	wv->call_data = aref_addr (menu_items, i);	prev_wv = wv;	if (! boundary_seen)	  left_count++;	nb_buttons++;	i += MENU_ITEMS_ITEM_LENGTH;      }    /* If the boundary was not specified,       by default put half on the left and half on the right.  */    if (! boundary_seen)      left_count = nb_buttons - nb_buttons / 2;    wv = make_widget_value (dialog_name, NULL, false, Qnil);    /*  Frame title: 'Q' = Question, 'I' = Information.        Can also have 'E' = Error if, one day, we want        a popup for errors. */    if (NILP (header))      dialog_name[0] = 'Q';    else      dialog_name[0] = 'I';//.........这里部分代码省略.........

Lisp_Objectw32_menu_show (struct frame *f, int x, int y, int menuflags,	       Lisp_Object title, const char **error){  int i;  int menu_item_selection;  HMENU menu;  POINT pos;  widget_value *wv, *save_wv = 0, *first_wv = 0, *prev_wv = 0;  widget_value **submenu_stack    = (widget_value **) alloca (menu_items_used * sizeof (widget_value *));  Lisp_Object *subprefix_stack    = (Lisp_Object *) alloca (menu_items_used * word_size);  int submenu_depth = 0;  bool first_pane;  *error = NULL;  if (menu_items_n_panes == 0)    return Qnil;  if (menu_items_used <= MENU_ITEMS_PANE_LENGTH)    {      *error = "Empty menu";      return Qnil;    }  block_input ();  /* Create a tree of widget_value objects     representing the panes and their items.  */  wv = make_widget_value ("menu", NULL, true, Qnil);  wv->button_type = BUTTON_TYPE_NONE;  first_wv = wv;  first_pane = true;  /* Loop over all panes and items, filling in the tree.  */  i = 0;  while (i < menu_items_used)    {      if (EQ (AREF (menu_items, i), Qnil))	{	  submenu_stack[submenu_depth++] = save_wv;	  save_wv = prev_wv;	  prev_wv = 0;	  first_pane = false;	  i++;	}      else if (EQ (AREF (menu_items, i), Qlambda))	{	  prev_wv = save_wv;	  save_wv = submenu_stack[--submenu_depth];	  first_pane = false;	  i++;	}      else if (EQ (AREF (menu_items, i), Qt)	       && submenu_depth != 0)	i += MENU_ITEMS_PANE_LENGTH;      /* Ignore a nil in the item list.	 It's meaningful only for dialog boxes.  */      else if (EQ (AREF (menu_items, i), Qquote))	i += 1;      else if (EQ (AREF (menu_items, i), Qt))	{	  /* Create a new pane.  */	  Lisp_Object pane_name, prefix;	  const char *pane_string;	  pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);	  prefix = AREF (menu_items, i + MENU_ITEMS_PANE_PREFIX);	  if (STRINGP (pane_name))	    {	      if (unicode_append_menu)		pane_name = ENCODE_UTF_8 (pane_name);	      else if (STRING_MULTIBYTE (pane_name))		pane_name = ENCODE_SYSTEM (pane_name);	      ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);	    }	  pane_string = (NILP (pane_name)			 ? "" : SSDATA (pane_name));	  /* If there is just one top-level pane, put all its items directly	     under the top-level menu.  */	  if (menu_items_n_panes == 1)	    pane_string = "";	  /* If the pane has a meaningful name,	     make the pane a top-level menu item	     with its items as a submenu beneath it.  */	  if (!(menuflags & MENU_KEYMAPS) && strcmp (pane_string, ""))	    {	      wv = make_widget_value (pane_string, NULL, true, Qnil);	      if (save_wv)		save_wv->next = wv;	      else		first_wv->contents = wv;	      if ((menuflags & MENU_KEYMAPS) && !NILP (prefix))		wv->name++;	      wv->button_type = BUTTON_TYPE_NONE;//.........这里部分代码省略.........

voidset_frame_menubar (struct frame *f, bool first_time, bool deep_p){  HMENU menubar_widget = f->output_data.w32->menubar_widget;  Lisp_Object items;  widget_value *wv, *first_wv, *prev_wv = 0;  int i, last_i;  int *submenu_start, *submenu_end;  int *submenu_top_level_items, *submenu_n_panes;  /* We must not change the menubar when actually in use.  */  if (f->output_data.w32->menubar_active)    return;  XSETFRAME (Vmenu_updating_frame, f);  if (! menubar_widget)    deep_p = true;  if (deep_p)    {      /* Make a widget-value tree representing the entire menu trees.  */      struct buffer *prev = current_buffer;      Lisp_Object buffer;      ptrdiff_t specpdl_count = SPECPDL_INDEX ();      int previous_menu_items_used = f->menu_bar_items_used;      Lisp_Object *previous_items	= (Lisp_Object *) alloca (previous_menu_items_used				  * word_size);      /* If we are making a new widget, its contents are empty,	 do always reinitialize them.  */      if (! menubar_widget)	previous_menu_items_used = 0;      buffer = XWINDOW (FRAME_SELECTED_WINDOW (f))->contents;      specbind (Qinhibit_quit, Qt);      /* Don't let the debugger step into this code	 because it is not reentrant.  */      specbind (Qdebug_on_next_call, Qnil);      record_unwind_save_match_data ();      if (NILP (Voverriding_local_map_menu_flag))	{	  specbind (Qoverriding_terminal_local_map, Qnil);	  specbind (Qoverriding_local_map, Qnil);	}      set_buffer_internal_1 (XBUFFER (buffer));      /* Run the hooks.  */      safe_run_hooks (Qactivate_menubar_hook);      safe_run_hooks (Qmenu_bar_update_hook);      fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));      items = FRAME_MENU_BAR_ITEMS (f);      /* Save the frame's previous menu bar contents data.  */      if (previous_menu_items_used)	memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,		previous_menu_items_used * word_size);      /* Fill in menu_items with the current menu bar contents.	 This can evaluate Lisp code.  */      save_menu_items ();      menu_items = f->menu_bar_vector;      menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;      submenu_start = (int *) alloca (ASIZE (items) * sizeof (int));      submenu_end = (int *) alloca (ASIZE (items) * sizeof (int));      submenu_n_panes = (int *) alloca (ASIZE (items) * sizeof (int));      submenu_top_level_items = (int *) alloca (ASIZE (items) * sizeof (int));      init_menu_items ();      for (i = 0; i < ASIZE (items); i += 4)	{	  Lisp_Object key, string, maps;	  last_i = i;	  key = AREF (items, i);	  string = AREF (items, i + 1);	  maps = AREF (items, i + 2);	  if (NILP (string))	    break;	  submenu_start[i] = menu_items_used;	  menu_items_n_panes = 0;	  submenu_top_level_items[i]	    = parse_single_submenu (key, string, maps);	  submenu_n_panes[i] = menu_items_n_panes;	  submenu_end[i] = menu_items_used;	}      finish_menu_items ();      /* Convert menu_items into widget_value trees//.........这里部分代码省略.........

widget_value *digest_single_submenu (int start, int end, bool top_level_items){  widget_value *wv, *prev_wv, *save_wv, *first_wv;  int i;  int submenu_depth = 0;  widget_value **submenu_stack;  bool panes_seen = 0;  struct frame *f = XFRAME (Vmenu_updating_frame);  USE_SAFE_ALLOCA;  SAFE_NALLOCA (submenu_stack, 1, menu_items_used);  wv = make_widget_value ("menu", NULL, true, Qnil);  wv->button_type = BUTTON_TYPE_NONE;  first_wv = wv;  save_wv = 0;  prev_wv = 0;  /* Loop over all panes and items made by the preceding call     to parse_single_submenu and construct a tree of widget_value objects.     Ignore the panes and items used by previous calls to     digest_single_submenu, even though those are also in menu_items.  */  i = start;  while (i < end)    {      if (EQ (AREF (menu_items, i), Qnil))	{	  submenu_stack[submenu_depth++] = save_wv;	  save_wv = prev_wv;	  prev_wv = 0;	  i++;	}      else if (EQ (AREF (menu_items, i), Qlambda))	{	  prev_wv = save_wv;	  save_wv = submenu_stack[--submenu_depth];	  i++;	}      else if (EQ (AREF (menu_items, i), Qt)	       && submenu_depth != 0)	i += MENU_ITEMS_PANE_LENGTH;      /* Ignore a nil in the item list.	 It's meaningful only for dialog boxes.  */      else if (EQ (AREF (menu_items, i), Qquote))	i += 1;      else if (EQ (AREF (menu_items, i), Qt))	{	  /* Create a new pane.  */	  Lisp_Object pane_name;	  const char *pane_string;	  panes_seen = 1;	  pane_name = AREF (menu_items, i + MENU_ITEMS_PANE_NAME);	  /* TTY menus display menu items via tty_write_glyphs, which	     will encode the strings as appropriate.  */	  if (!FRAME_TERMCAP_P (f))	    {#ifdef HAVE_NTGUI	      if (STRINGP (pane_name))		{		  if (unicode_append_menu)		    /* Encode as UTF-8 for now.  */		    pane_name = ENCODE_UTF_8 (pane_name);		  else if (STRING_MULTIBYTE (pane_name))		    pane_name = ENCODE_SYSTEM (pane_name);		  ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);		}#elif defined (USE_LUCID) && defined (HAVE_XFT)	      if (STRINGP (pane_name))		{		  pane_name = ENCODE_UTF_8 (pane_name);		  ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);		}#elif !defined (HAVE_MULTILINGUAL_MENU)	      if (STRINGP (pane_name) && STRING_MULTIBYTE (pane_name))		{		  pane_name = ENCODE_MENU_STRING (pane_name);		  ASET (menu_items, i + MENU_ITEMS_PANE_NAME, pane_name);		}#endif	    }	  pane_string = (NILP (pane_name)			 ? "" : SSDATA (pane_name));	  /* If there is just one top-level pane, put all its items directly	     under the top-level menu.  */	  if (menu_items_n_panes == 1)	    pane_string = "";	  /* If the pane has a meaningful name,	     make the pane a top-level menu item	     with its items as a submenu beneath it.  */	  if (strcmp (pane_string, ""))	    {	      /* Set value to 1 so update_submenu_strings can handle '@'.  */	      wv = make_widget_value (NULL, (char *) 1, true, Qnil);	      if (save_wv)//.........这里部分代码省略.........

static Lisp_Objectxftfont_open (struct frame *f, Lisp_Object entity, int pixel_size){  FcResult result;  Display *display = FRAME_X_DISPLAY (f);  Lisp_Object val, filename, idx, font_object;  FcPattern *pat = NULL, *match;  struct xftfont_info *xftfont_info = NULL;  struct font *font;  double size = 0;  XftFont *xftfont = NULL;  int spacing;  char name[256];  int len, i;  XGlyphInfo extents;  FT_Face ft_face;  FcMatrix *matrix;  val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX));  if (! CONSP (val))    return Qnil;  val = XCDR (val);  filename = XCAR (val);  idx = XCDR (val);  size = XINT (AREF (entity, FONT_SIZE_INDEX));  if (size == 0)    size = pixel_size;  pat = FcPatternCreate ();  FcPatternAddInteger (pat, FC_WEIGHT, FONT_WEIGHT_NUMERIC (entity));  i = FONT_SLANT_NUMERIC (entity) - 100;  if (i < 0) i = 0;  FcPatternAddInteger (pat, FC_SLANT, i);  FcPatternAddInteger (pat, FC_WIDTH, FONT_WIDTH_NUMERIC (entity));  FcPatternAddDouble (pat, FC_PIXEL_SIZE, pixel_size);  val = AREF (entity, FONT_FAMILY_INDEX);  if (! NILP (val))    FcPatternAddString (pat, FC_FAMILY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));  val = AREF (entity, FONT_FOUNDRY_INDEX);  if (! NILP (val))    FcPatternAddString (pat, FC_FOUNDRY, (FcChar8 *) SDATA (SYMBOL_NAME (val)));  val = AREF (entity, FONT_SPACING_INDEX);  if (! NILP (val))    FcPatternAddInteger (pat, FC_SPACING, XINT (val));  val = AREF (entity, FONT_DPI_INDEX);  if (! NILP (val))    {      double dbl = XINT (val);      FcPatternAddDouble (pat, FC_DPI, dbl);    }  val = AREF (entity, FONT_AVGWIDTH_INDEX);  if (INTEGERP (val) && XINT (val) == 0)    FcPatternAddBool (pat, FC_SCALABLE, FcTrue);  /* This is necessary to identify the exact font (e.g. 10x20.pcf.gz     over 10x20-ISO8859-1.pcf.gz).  */  FcPatternAddCharSet (pat, FC_CHARSET, ftfont_get_fc_charset (entity));  xftfont_add_rendering_parameters (pat, entity);  FcPatternAddString (pat, FC_FILE, (FcChar8 *) SDATA (filename));  FcPatternAddInteger (pat, FC_INDEX, XINT (idx));  block_input ();  /* Make sure that the Xrender extension is added before the Xft one.     Otherwise, the close-display hook set by Xft is called after the     one for Xrender, and the former tries to re-add the latter.  This     results in inconsistency of internal states and leads to X     protocol error when one reconnects to the same X server.     (Bug#1696)  */  {    int event_base, error_base;    XRenderQueryExtension (display, &event_base, &error_base);  }  /* Substitute in values from X resources and XftDefaultSet.  */  XftDefaultSubstitute (display, FRAME_X_SCREEN_NUMBER (f), pat);  match = XftFontMatch (display, FRAME_X_SCREEN_NUMBER (f), pat, &result);  xftfont_fix_match (pat, match);  FcPatternDestroy (pat);  xftfont = XftFontOpenPattern (display, match);  if (!xftfont)    {      unblock_input ();      XftPatternDestroy (match);      return Qnil;    }  ft_face = XftLockFace (xftfont);  unblock_input ();  /* We should not destroy PAT here because it is kept in XFTFONT and     destroyed automatically when XFTFONT is closed.  */  font_object = font_make_object (VECSIZE (struct xftfont_info), entity, size);  ASET (font_object, FONT_TYPE_INDEX, Qxft);  len = font_unparse_xlfd (entity, size, name, 256);  if (len > 0)    ASET (font_object, FONT_NAME_INDEX, make_string (name, len));  len = font_unparse_fcname (entity, size, name, 256);  if (len > 0)//.........这里部分代码省略.........

//.........这里部分代码省略.........	     make the pane a top-level menu item	     with its items as a submenu beneath it.  */	  if (strcmp (pane_string, ""))	    {	      wv = xmalloc_widget_value ();	      if (save_wv)		save_wv->next = wv;	      else		first_wv->contents = wv;	      wv->lname = pane_name;              /* Set value to 1 so update_submenu_strings can handle '@'  */	      wv->value = (char *)1;	      wv->enabled = 1;	      wv->button_type = BUTTON_TYPE_NONE;	      wv->help = Qnil;	      save_wv = wv;	    }	  else	    save_wv = first_wv;	  prev_wv = 0;	  i += MENU_ITEMS_PANE_LENGTH;	}      else	{	  /* Create a new item within current pane.  */	  Lisp_Object item_name, enable, descrip, def, type, selected;	  Lisp_Object help;	  /* All items should be contained in panes.  */	  if (panes_seen == 0)	    abort ();	  item_name = AREF (menu_items, i + MENU_ITEMS_ITEM_NAME);	  enable = AREF (menu_items, i + MENU_ITEMS_ITEM_ENABLE);	  descrip = AREF (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY);	  def = AREF (menu_items, i + MENU_ITEMS_ITEM_DEFINITION);	  type = AREF (menu_items, i + MENU_ITEMS_ITEM_TYPE);	  selected = AREF (menu_items, i + MENU_ITEMS_ITEM_SELECTED);	  help = AREF (menu_items, i + MENU_ITEMS_ITEM_HELP);#ifdef HAVE_NTGUI	  if (STRINGP (item_name))	    {	      if (unicode_append_menu)		item_name = ENCODE_UTF_8 (item_name);	      else if (STRING_MULTIBYTE (item_name))		item_name = ENCODE_SYSTEM (item_name);	      ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);	    }	  if (STRINGP (descrip) && STRING_MULTIBYTE (descrip))	    {	      descrip = ENCODE_SYSTEM (descrip);	      ASET (menu_items, i + MENU_ITEMS_ITEM_EQUIV_KEY, descrip);	    }#elif USE_LUCID	  if (STRINGP (item_name))	    {              item_name = ENCODE_UTF_8 (item_name);	      ASET (menu_items, i + MENU_ITEMS_ITEM_NAME, item_name);	    }	  if (STRINGP (descrip))	    {

static VALUEreduce0(VALUE val, VALUE data, VALUE self){    struct cparse_params *v;    VALUE reduce_to, reduce_len, method_id;    long len;    ID mid;    VALUE tmp, tmp_t = Qundef, tmp_v = Qundef;    long i, k1, k2;    VALUE goto_state;    Data_Get_Struct(data, struct cparse_params, v);    reduce_len = RARRAY_PTR(v->reduce_table)[v->ruleno];    reduce_to  = RARRAY_PTR(v->reduce_table)[v->ruleno+1];    method_id  = RARRAY_PTR(v->reduce_table)[v->ruleno+2];    len = NUM2LONG(reduce_len);    mid = value_to_id(method_id);    /* call action */    if (len == 0) {        tmp = Qnil;        if (mid != id_noreduce)            tmp_v = rb_ary_new();        if (v->debug)            tmp_t = rb_ary_new();    }    else {        if (mid != id_noreduce) {            tmp_v = GET_TAIL(v->vstack, len);            tmp = RARRAY_PTR(tmp_v)[0];        }        else {            tmp = RARRAY_PTR(v->vstack)[ RARRAY_LEN(v->vstack) - len ];        }        CUT_TAIL(v->vstack, len);        if (v->debug) {            tmp_t = GET_TAIL(v->tstack, len);            CUT_TAIL(v->tstack, len);        }        CUT_TAIL(v->state, len);    }    if (mid != id_noreduce) {        if (v->use_result_var) {            tmp = rb_funcall(v->parser, mid,                             3, tmp_v, v->vstack, tmp);        }        else {            tmp = rb_funcall(v->parser, mid,                             2, tmp_v, v->vstack);        }    }    /* then push result */    PUSH(v->vstack, tmp);    if (v->debug) {        PUSH(v->tstack, reduce_to);        rb_funcall(v->parser, id_d_reduce,                   4, tmp_t, reduce_to, v->tstack, v->vstack);    }    /* calculate transition state */    if (RARRAY_LEN(v->state) == 0)        rb_raise(RaccBug, "state stack unexpectedly empty");    k2 = num_to_long(LAST_I(v->state));    k1 = num_to_long(reduce_to) - v->nt_base;    D_printf("(goto) k1=%ld/n", k1);    D_printf("(goto) k2=%ld/n", k2);    tmp = AREF(v->goto_pointer, k1);    if (NIL_P(tmp)) goto notfound;    i = NUM2LONG(tmp) + k2;    D_printf("(goto) i=%ld/n", i);    if (i < 0) goto notfound;    goto_state = AREF(v->goto_table, i);    if (NIL_P(goto_state)) {        D_puts("(goto) table[i] == nil");        goto notfound;    }    D_printf("(goto) table[i]=%ld (goto_state)/n", NUM2LONG(goto_state));    tmp = AREF(v->goto_check, i);    if (NIL_P(tmp)) {        D_puts("(goto) check[i] == nil");        goto notfound;    }    if (tmp != LONG2NUM(k1)) {        D_puts("(goto) check[i] != table[i]");        goto notfound;    }    D_printf("(goto) check[i]=%ld/n", NUM2LONG(tmp));    D_puts("(goto) found");  transit:    PUSH(v->state, goto_state);    v->curstate = NUM2LONG(goto_state);    return INT2FIX(0);  notfound://.........这里部分代码省略.........

static voidparse_main(struct cparse_params *v, VALUE tok, VALUE val, int resume){    long i;              /* table index */    long act;            /* action type */    VALUE act_value;     /* action type, VALUE version */    int read_next = 1;   /* true if we need to read next token */    VALUE tmp;    if (resume)        goto resume;        while (1) {        D_puts("");        D_puts("---- enter new loop ----");        D_puts("");        D_printf("(act) k1=%ld/n", v->curstate);        tmp = AREF(v->action_pointer, v->curstate);        if (NIL_P(tmp)) goto notfound;        D_puts("(act) pointer[k1] ok");        i = NUM2LONG(tmp);        D_printf("read_next=%d/n", read_next);        if (read_next && (v->t != vFINAL_TOKEN)) {            if (v->lex_is_iterator) {                D_puts("resuming...");                if (v->fin) rb_raise(rb_eArgError, "token given after EOF");                v->i = i;  /* save i */                return;              resume:                D_puts("resumed");                i = v->i;  /* load i */            }            else {                D_puts("next_token");                tmp = rb_funcall(v->parser, id_nexttoken, 0);                extract_user_token(v, tmp, &tok, &val);            }            /* convert token */            v->t = rb_hash_aref(v->token_table, tok);            if (NIL_P(v->t)) {                v->t = vERROR_TOKEN;            }            D_printf("(act) t(k2)=%ld/n", NUM2LONG(v->t));            if (v->debug) {                rb_funcall(v->parser, id_d_read_token,                           3, v->t, tok, val);            }        }        read_next = 0;        i += NUM2LONG(v->t);        D_printf("(act) i=%ld/n", i);        if (i < 0) goto notfound;        act_value = AREF(v->action_table, i);        if (NIL_P(act_value)) goto notfound;        act = NUM2LONG(act_value);        D_printf("(act) table[i]=%ld/n", act);        tmp = AREF(v->action_check, i);        if (NIL_P(tmp)) goto notfound;        if (NUM2LONG(tmp) != v->curstate) goto notfound;        D_printf("(act) check[i]=%ld/n", NUM2LONG(tmp));        D_puts("(act) found");      act_fixed:        D_printf("act=%ld/n", act);        goto handle_act;          notfound:        D_puts("(act) not found: use default");        act_value = AREF(v->action_default, v->curstate);        act = NUM2LONG(act_value);        goto act_fixed;      handle_act:        if (act > 0 && act < v->shift_n) {            D_puts("shift");            if (v->errstatus > 0) {                v->errstatus--;                rb_ivar_set(v->parser, id_errstatus, LONG2NUM(v->errstatus));            }            SHIFT(v, act, v->t, val);            read_next = 1;        }        else if (act < 0 && act > -(v->reduce_n)) {            D_puts("reduce");            REDUCE(v, act);        }        else if (act == -(v->reduce_n)) {            goto error;          error_recovered:            ;   /* goto label requires stmt */        }        else if (act == v->shift_n) {            D_puts("accept");            goto accept;//.........这里部分代码省略.........

static voidsingle_menu_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy, void *skp_v){  Lisp_Object map, item_string, enabled;  struct gcpro gcpro1, gcpro2;  bool res;  struct skp *skp = skp_v;  /* Parse the menu item and leave the result in item_properties.  */  GCPRO2 (key, item);  res = parse_menu_item (item, 0);  UNGCPRO;  if (!res)    return;			/* Not a menu item.  */  map = AREF (item_properties, ITEM_PROPERTY_MAP);  enabled = AREF (item_properties, ITEM_PROPERTY_ENABLE);  item_string = AREF (item_properties, ITEM_PROPERTY_NAME);  if (!NILP (map) && SREF (item_string, 0) == '@')    {      if (!NILP (enabled))	/* An enabled separate pane. Remember this to handle it later.  */	skp->pending_maps = Fcons (Fcons (map, Fcons (item_string, key)),				   skp->pending_maps);      return;    }  /* Simulate radio buttons and toggle boxes by putting a prefix in     front of them.  */  if (!have_boxes ())    {      char const *prefix = 0;      Lisp_Object type = AREF (item_properties, ITEM_PROPERTY_TYPE);      if (!NILP (type))	{	  Lisp_Object selected	    = AREF (item_properties, ITEM_PROPERTY_SELECTED);	  if (skp->notbuttons)	    /* The first button. Line up previous items in this menu.  */	    {	      int idx = skp->notbuttons; /* Index for first item this menu.  */	      int submenu = 0;	      Lisp_Object tem;	      while (idx < menu_items_used)		{		  tem		    = AREF (menu_items, idx + MENU_ITEMS_ITEM_NAME);		  if (NILP (tem))		    {		      idx++;		      submenu++;		/* Skip sub menu.  */		    }		  else if (EQ (tem, Qlambda))		    {		      idx++;		      submenu--;		/* End sub menu.  */		    }		  else if (EQ (tem, Qt))		    idx += 3;		/* Skip new pane marker. */		  else if (EQ (tem, Qquote))		    idx++;		/* Skip a left, right divider. */		  else		    {		      if (!submenu && SREF (tem, 0) != '/0'			  && SREF (tem, 0) != '-')			ASET (menu_items, idx + MENU_ITEMS_ITEM_NAME,			      concat2 (SCOPED_STRING ("    "), tem));		      idx += MENU_ITEMS_ITEM_LENGTH;		    }		}	      skp->notbuttons = 0;	    }	  /* Calculate prefix, if any, for this item.  */	  if (EQ (type, QCtoggle))	    prefix = NILP (selected) ? "[ ] " : "[X] ";	  else if (EQ (type, QCradio))	    prefix = NILP (selected) ? "( ) " : "(*) ";	}      /* Not a button. If we have earlier buttons, then we need a prefix.  */      else if (!skp->notbuttons && SREF (item_string, 0) != '/0'	       && SREF (item_string, 0) != '-')	prefix = "    ";      if (prefix)	item_string = concat2 (SCOPED_STRING (prefix), item_string);  }  if ((FRAME_TERMCAP_P (XFRAME (Vmenu_updating_frame))       || FRAME_MSDOS_P (XFRAME (Vmenu_updating_frame)))      && !NILP (map))    /* Indicate visually that this is a submenu.  */    item_string = concat2 (item_string, SCOPED_STRING (" >"));  push_menu_item (item_string, enabled, key,		  AREF (item_properties, ITEM_PROPERTY_DEF),		  AREF (item_properties, ITEM_PROPERTY_KEYEQ),//.........这里部分代码省略.........

voidmenubar_selection_callback (struct frame *f, void * client_data){  Lisp_Object prefix, entry;  Lisp_Object vector;  Lisp_Object *subprefix_stack;  int submenu_depth = 0;  int i;  if (!f)    return;  entry = Qnil;  subprefix_stack = (Lisp_Object *) alloca (f->menu_bar_items_used * word_size);  vector = f->menu_bar_vector;  prefix = Qnil;  i = 0;  while (i < f->menu_bar_items_used)    {      if (EQ (AREF (vector, i), Qnil))	{	  subprefix_stack[submenu_depth++] = prefix;	  prefix = entry;	  i++;	}      else if (EQ (AREF (vector, i), Qlambda))	{	  prefix = subprefix_stack[--submenu_depth];	  i++;	}      else if (EQ (AREF (vector, i), Qt))	{	  prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);	  i += MENU_ITEMS_PANE_LENGTH;	}      else	{	  entry = AREF (vector, i + MENU_ITEMS_ITEM_VALUE);	  /* The UINT_PTR cast avoids a warning.  There's no problem	     as long as pointers have enough bits to hold small integers.  */	  if ((int) (UINT_PTR) client_data == i)	    {	      int j;	      struct input_event buf;	      Lisp_Object frame;	      EVENT_INIT (buf);	      XSETFRAME (frame, f);	      buf.kind = MENU_BAR_EVENT;	      buf.frame_or_window = frame;	      buf.arg = frame;	      kbd_buffer_store_event (&buf);	      for (j = 0; j < submenu_depth; j++)		if (!NILP (subprefix_stack[j]))		  {		    buf.kind = MENU_BAR_EVENT;		    buf.frame_or_window = frame;		    buf.arg = subprefix_stack[j];		    kbd_buffer_store_event (&buf);		  }	      if (!NILP (prefix))		{		  buf.kind = MENU_BAR_EVENT;		  buf.frame_or_window = frame;		  buf.arg = prefix;		  kbd_buffer_store_event (&buf);		}	      buf.kind = MENU_BAR_EVENT;	      buf.frame_or_window = frame;	      buf.arg = entry;	      /* Free memory used by owner-drawn and help-echo strings.  */	      w32_free_menu_strings (FRAME_W32_WINDOW (f));	      kbd_buffer_store_event (&buf);	      f->output_data.w32->menubar_active = 0;	      return;	    }	  i += MENU_ITEMS_ITEM_LENGTH;	}    }  /* Free memory used by owner-drawn and help-echo strings.  */  w32_free_menu_strings (FRAME_W32_WINDOW (f));  f->output_data.w32->menubar_active = 0;}

voidfind_and_call_menu_selection (struct frame *f, int menu_bar_items_used,			      Lisp_Object vector, void *client_data){  Lisp_Object prefix, entry;  Lisp_Object *subprefix_stack;  int submenu_depth = 0;  int i;  USE_SAFE_ALLOCA;  entry = Qnil;  SAFE_NALLOCA (subprefix_stack, 1, menu_bar_items_used);  prefix = Qnil;  i = 0;  while (i < menu_bar_items_used)    {      if (EQ (AREF (vector, i), Qnil))	{	  subprefix_stack[submenu_depth++] = prefix;	  prefix = entry;	  i++;	}      else if (EQ (AREF (vector, i), Qlambda))	{	  prefix = subprefix_stack[--submenu_depth];	  i++;	}      else if (EQ (AREF (vector, i), Qt))	{	  prefix = AREF (vector, i + MENU_ITEMS_PANE_PREFIX);	  i += MENU_ITEMS_PANE_LENGTH;	}      else	{	  entry = AREF (vector, i + MENU_ITEMS_ITEM_VALUE);	  /* Treat the pointer as an integer.  There's no problem	     as long as pointers have enough bits to hold small integers.  */	  if ((intptr_t) client_data == i)	    {	      int j;	      struct input_event buf;	      Lisp_Object frame;	      EVENT_INIT (buf);	      XSETFRAME (frame, f);	      buf.kind = MENU_BAR_EVENT;	      buf.frame_or_window = frame;	      buf.arg = frame;	      kbd_buffer_store_event (&buf);	      for (j = 0; j < submenu_depth; j++)		if (!NILP (subprefix_stack[j]))		  {		    buf.kind = MENU_BAR_EVENT;		    buf.frame_or_window = frame;		    buf.arg = subprefix_stack[j];		    kbd_buffer_store_event (&buf);		  }	      if (!NILP (prefix))		{		  buf.kind = MENU_BAR_EVENT;		  buf.frame_or_window = frame;		  buf.arg = prefix;		  kbd_buffer_store_event (&buf);		}	      buf.kind = MENU_BAR_EVENT;	      buf.frame_or_window = frame;	      buf.arg = entry;	      kbd_buffer_store_event (&buf);	      break;	    }	  i += MENU_ITEMS_ITEM_LENGTH;	}    }  SAFE_FREE ();}

static json_t *lisp_to_json_toplevel_1 (Lisp_Object lisp){  json_t *json;  ptrdiff_t count;  if (VECTORP (lisp))    {      ptrdiff_t size = ASIZE (lisp);      json = json_check (json_array ());      count = SPECPDL_INDEX ();      record_unwind_protect_ptr (json_release_object, json);      for (ptrdiff_t i = 0; i < size; ++i)        {          int status            = json_array_append_new (json, lisp_to_json (AREF (lisp, i)));          if (status == -1)            json_out_of_memory ();        }      eassert (json_array_size (json) == size);    }  else if (HASH_TABLE_P (lisp))    {      struct Lisp_Hash_Table *h = XHASH_TABLE (lisp);      json = json_check (json_object ());      count = SPECPDL_INDEX ();      record_unwind_protect_ptr (json_release_object, json);      for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)        if (!NILP (HASH_HASH (h, i)))          {            Lisp_Object key = json_encode (HASH_KEY (h, i));            /* We can't specify the length, so the string must be               null-terminated.  */            check_string_without_embedded_nulls (key);            const char *key_str = SSDATA (key);            /* Reject duplicate keys.  These are possible if the hash               table test is not `equal'.  */            if (json_object_get (json, key_str) != NULL)              wrong_type_argument (Qjson_value_p, lisp);            int status = json_object_set_new (json, key_str,                                              lisp_to_json (HASH_VALUE (h, i)));            if (status == -1)              {                /* A failure can be caused either by an invalid key or                   by low memory.  */                json_check_utf8 (key);                json_out_of_memory ();              }          }    }  else if (NILP (lisp))    return json_check (json_object ());  else if (CONSP (lisp))    {      Lisp_Object tail = lisp;      json = json_check (json_object ());      count = SPECPDL_INDEX ();      record_unwind_protect_ptr (json_release_object, json);      bool is_plist = !CONSP (XCAR (tail));      FOR_EACH_TAIL (tail)        {          const char *key_str;          Lisp_Object value;          Lisp_Object key_symbol;          if (is_plist)            {              key_symbol = XCAR (tail);              tail = XCDR (tail);              CHECK_CONS (tail);              value = XCAR (tail);              if (EQ (tail, li.tortoise)) circular_list (lisp);            }          else            {              Lisp_Object pair = XCAR (tail);              CHECK_CONS (pair);              key_symbol = XCAR (pair);              value = XCDR (pair);            }          CHECK_SYMBOL (key_symbol);          Lisp_Object key = SYMBOL_NAME (key_symbol);          /* We can't specify the length, so the string must be             null-terminated.  */          check_string_without_embedded_nulls (key);          key_str = SSDATA (key);          /* In plists, ensure leading ":" in keys is stripped.  It             will be reconstructed later in `json_to_lisp'.*/          if (is_plist && ':' == key_str[0] && key_str[1])            {              key_str = &key_str[1];            }          /* Only add element if key is not already present.  */          if (json_object_get (json, key_str) == NULL)            {              int status                = json_object_set_new (json, key_str, lisp_to_json (value));              if (status == -1)                json_out_of_memory ();            }        }//.........这里部分代码省略.........