mwmparse.c

安装DDD之前

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss;
  yyvsp = yyvs;

  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed. so pushing a state here evens the stacks.
     */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyss + yystacksize - 1 <= yyssp)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
	/* Give user a chance to reallocate the stack. Use copies of
	   these so that the &'s don't force the real ones into
	   memory.  */
	YYSTYPE *yyvs1 = yyvs;
	short *yyss1 = yyss;


	/* Each stack pointer address is followed by the size of the
	   data in use in that stack, in bytes.  This used to be a
	   conditional around just the two extra args, but that might
	   be undefined if yyoverflow is a macro.  */
	yyoverflow ("parser stack overflow",
		    &yyss1, yysize * sizeof (*yyssp),
		    &yyvs1, yysize * sizeof (*yyvsp),

		    &yystacksize);

	yyss = yyss1;
	yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyoverflowlab;
# else
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
	goto yyoverflowlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
	yystacksize = YYMAXDEPTH;

      {
	short *yyss1 = yyss;
	union yyalloc *yyptr =
	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
	if (! yyptr)
	  goto yyoverflowlab;
	YYSTACK_RELOCATE (yyss);
	YYSTACK_RELOCATE (yyvs);

#  undef YYSTACK_RELOCATE
	if (yyss1 != yyssa)
	  YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;


      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
		  (unsigned long int) yystacksize));

      if (yyss + yystacksize - 1 <= yyssp)
	YYABORT;
    }

  YYDPRINTF ((stderr, "Entering state %d\n", yystate));

  goto yybackup;

/*-----------.
| yybackup.  |
`-----------*/
yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

  yyn = yypact[yystate];
  if (yyn == YYPACT_NINF)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = YYLEX;
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yyn == 0 || yyn == YYTABLE_NINF)
	goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  if (yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */
  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  *++yyvsp = yylval;


  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  yystate = yyn;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];


  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 7:
#line 264 "mwmparse.y"
    {
			    if (!skip_test) {
				if (button_bind_found == False) {
				    if (strcmp(yyvsp[0].string, pscr->button_bindings) == 0)
					button_bind_match = True;
				    else
					button_bind_match = False;
				}
				else if (strcmp(yyvsp[0].string, pscr->button_bindings) == 0) {
				    yyerror("Ignoring duplicate button bindings");
				    button_bind_match = False;
				}
				else
				    button_bind_match = False;
			    }
			    else
				button_bind_match = True;
			}
    break;

  case 10:
#line 287 "mwmparse.y"
    {
			    yyerror("Invalid button binding");
			    yyerrok;
			    yyclearin;
			}
    break;

  case 12:
#line 296 "mwmparse.y"
    {
			    int contexts = yyvsp[-1].number;
			    int mods, func;
			    MenuItem *mi = NULL;
			    MouseButton *temp = NULL, *ptr;

			    if (!button_bind_match)
				break;

			    mods = yyvsp[-2].button.modifiers;
			    if ((contexts & C_WINDOW) &&
				(((mods == 0) || mods == AnyModifier))) {
			        pscr->buttons2grab &= ~(yyvsp[-2].button.button);
			    }
			
			    func = yyvsp[0].function.func;

			    if ((func == F_EXEC) ||
				(func == F_RESTART) ||
			        (func == F_CIRCULATE_UP) ||
				(func == F_CIRCULATE_DOWN) ||
			        (func == F_WARP)) {
			        mi = (MenuItem *)XtMalloc(sizeof(MenuItem));
			
			        mi->next = (MenuItem *) NULL;
			        mi->prev = (MenuItem *) NULL;
			        if ((func == F_EXEC) || (func == F_RESTART)) {
			            mi->item = XtNewString("DOIT");
			            mi->action = yyvsp[0].function.arg;
			        }
			        else {
			            mi->item = XtNewString("DONT DOIT");
			            mi->action = yyvsp[0].function.arg;
			        }
				mi->item2 = "";
			        mi->state = 0;
			        mi->func = func;
			        mi->strlen = strlen(mi->item);
				mi->strlen2 = 0;
			        mi->val1 = 0;
			        mi->val2 = 0;
			        mi->val1_unit = 1;
			        mi->val2_unit = 1;
			    }

			    temp = pscr->buttons;
			    pscr->buttons =
				(MouseButton *)XtMalloc(sizeof(MouseButton));
			    pscr->buttons->func = func;
			    if (func == F_POPUP)
				pscr->buttons->menu = (MenuRoot *)yyvsp[0].function.arg;
			    else if (func == F_W_POPUP)
				pscr->buttons->menu = (MenuRoot *)DEFAULT_WIN_MENU_NAME;
			    else
				pscr->buttons->menu = NULL;
			    pscr->buttons->item = mi;
			    pscr->buttons->button =
				ffs(yyvsp[-2].button.button) - 8;
			    pscr->buttons->context = contexts;
			    pscr->buttons->modifier = mods;
			    pscr->buttons->mask = yyvsp[-2].button.event;
			    pscr->buttons->count = yyvsp[-2].button.count;
			    pscr->buttons->val1 = 0;
			    pscr->buttons->val2 = 0;
			    pscr->buttons->val1_unit = pscr->d_width;
			    pscr->buttons->val2_unit = pscr->d_height;

			    /* if duplicate, skip second */
			    for (ptr = temp;
				 ptr != NULL;
				 ptr = ptr->next) {
                              /* If everything is the same except for having
                                  func's F_POPUP and F_WINDOWLIST, the
                                  second is a duplicate */
                               if (((ptr->func == F_POPUP || 
                                     ptr->func == F_WINDOWLIST) && 
                                    (pscr->buttons->func == F_POPUP || 
                                     pscr->buttons->func == F_WINDOWLIST)) &&
				    ptr->modifier == pscr->buttons->modifier &&
				    ptr->mask == pscr->buttons->mask &&
                                   ptr->count == pscr->buttons->count &&
                                   ptr->context == pscr->buttons->context &&
                                   ptr->button  == pscr->buttons->button) {

                                   XtFree((char *)pscr->buttons);
                                   pscr->buttons = temp;
                                   break;
                               }

                               if (ptr->func == pscr->buttons->func &&
                                   ptr->modifier == pscr->buttons->modifier &&
                                   ptr->mask == pscr->buttons->mask &&
                                   ptr->count == pscr->buttons->count &&
                                   ptr->button == pscr->buttons->button) {
				    ptr->context |= pscr->buttons->context;
				    XtFree((char *)pscr->buttons);
				    pscr->buttons = temp;
				    break;
				}
			    }
			    if (ptr == NULL)
				pscr->buttons->next = temp;
			}
    break;

  case 13:
#line 402 "mwmparse.y"
    {
			    if (!skip_test) {
				if (key_bind_found == False) {
				    if (strcmp(yyvsp[0].string, pscr->key_bindings) == 0)
					key_bind_match = True;
				    else
					key_bind_match = False;
				}
				else if (strcmp(yyvsp[0].string, pscr->key_bindings) == 0) {
				    yyerror("Ignoring duplicate key bindings");
					key_bind_match = False;
				}
				else
				    key_bind_match = False;
			    }
			    else
				key_bind_match = True;
			}
    break;

  case 16:
#line 425 "mwmparse.y"
    {
			    yyerror("Invalid key binding");
			    yyerrok;
			    yyclearin;
			}
    break;

  case 18:
#line 434 "mwmparse.y"
    {
			    FuncKey        *tmp = NULL;
			    KeySym          keysym;
			    KeyCode         keycode;
			    int             i, min, max;
			    int func, contexts;
			    char *ptr;

			    if (!key_bind_match)
				break;

			    ptr = yyvsp[0].function.arg;
			    func = yyvsp[0].function.func;
			    contexts = yyvsp[-1].number;

			    /*
			     * Don't let a 0 keycode go through, since that
			     * means AnyKey to the XGrabKey call in GrabKeys().
			     */
			    keysym = yyvsp[-2].hotkey.key;
			    if (keysym == 0)
				break;
			    if ((keycode = XKeysymToKeycode(dpy, yyvsp[-2].hotkey.key)) == 0)
				break;

			    XDisplayKeycodes(dpy, &min, &max);
			    for (i = min; i <= max; i++) {
				if (XKeycodeToKeysym(dpy, i, 0) == keysym) {
				    tmp = (FuncKey *)XtMalloc(sizeof(FuncKey));
				    tmp->next = pscr->keys;
				    pscr->keys = tmp;

				    tmp->name = "HOTKEY";
				    tmp->keycode = i;
				    tmp->cont = contexts;
				    tmp->mods = yyvsp[-2].hotkey.modifiers;
				    tmp->func = func;
				    if (func == F_W_POPUP)
					tmp->action = DEFAULT_WIN_MENU_NAME;
				    else
					tmp->action = ptr;
				    tmp->val1 = 0;
				    tmp->val2 = 0;
				    tmp->val1_unit = pscr->d_width;
				    tmp->val2_unit = pscr->d_height;
				    tmp->menu = NULL;
				}
			    }
			}
    break;

  case 19:
#line 486 "mwmparse.y"
    {
			    num_items = 0;
			    cur_menu = MENU_Create(yyvsp[0].string);
			}
    break;

  case 20: