graphicparse.c

編譯器的虛擬yacc工具

void HandleToken(ParseTreeHdl tokenTree)
   {
   /* push the token on the "stack"*/
   AddLast(gParseTreeList, tokenTree);
   /* update the screen*/
   DrawAll();
   }

void SetupGc(void)
/* set up the graphics context. */
   {
   int foreground,
       background;
   XGCValues vals;
   Arg al[10];
   int ac;
 
   /* get the current fg and bg colors. */
   ac = 0;
   XtSetArg(al[ac], XmNforeground, &foreground); ac++;
   XtSetArg(al[ac], XmNbackground, &background); ac++;
   XtGetValues(gTreeDrawingArea, al, ac);
 
   /* create the gGC. */
   vals.foreground = foreground;
   vals.background = background;
   gGC = XtGetGC(gTreeDrawingArea, GCForeground | GCBackground, &vals);
   }

void ButtonCB(Widget theWidget, int clientData, XtPointer callData)
/* gets called when a push button gets clicked */
   {
   switch(clientData)
      {
      case START:
         gStepParse_flag = REDUCTIONS;
         CreateParseTreeList(&gParseTreeList);
         DrawStack();
         XtSetSensitive(gStartButton, FALSE);
         XtSetSensitive(gStepButton, TRUE);
         XtSetSensitive(gMultiStepButton, TRUE);
         XtSetSensitive(gGoButton, TRUE);
         break;
      case STEP:
         if (yyparse() != 2)
            {
            XtSetSensitive(gStepButton, FALSE);
            XtSetSensitive(gMultiStepButton, FALSE);
            XtSetSensitive(gGoButton, FALSE);
            }
         break;
      case MULTISTEP:
         XtManageChild(gDialog);
         break;
      case GO:
         gStepParse_flag = NORMAL;
         yyparse();
         XtSetSensitive(gStepButton, FALSE);
         XtSetSensitive(gMultiStepButton, FALSE);
         XtSetSensitive(gGoButton, FALSE);
         break;
      case QUIT:
         exit(0);
         break;
      default:
         exit(1);
         break;
      }
   }

void DialogCB(Widget theWidget, int clientData, XmSelectionBoxCallbackStruct *callData)
/* gets called when a button in the dialog initiated by clicking the MultiStep button gets clicked */
   {
   char *s;
   int i,
       steps;
   int flag = 1;
 
   switch(clientData)
      {
      case OK:
         /* get the string from the event structure. */
         XmStringGetLtoR(callData->value, gCharSet, &s);
         steps = atoi(s);
         for (i = 1; (i <= steps) && flag; i++)
            {
            if (yyparse() != 2)
               {
               flag = 0;
               XtSetSensitive(gStepButton, FALSE);
               XtSetSensitive(gMultiStepButton, FALSE);
               XtSetSensitive(gGoButton, FALSE);
               }
            }
         XtFree(s);
         break;
      case CANCEL:
         break;
      }
   /* make the dialog box invisible */
   XtUnmanageChild(theWidget);
   }
 
void ExposeCB(Widget theWidget, int clientData, XtPointer callData)
/* gets called when some part of one of the drawing areas gets exposed */
   {
   switch(clientData)
      {
      case TREE:
         {
         XClearArea(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), 0, 0, 0, 0, FALSE);
         DrawTrees();
         break;
         }
      case STACK:
         {
         DrawStack();
         break;
         }
      default:
         {
         break;
         }
      }
   }

void ResizeCB(Widget theWidget, int clientData, XtPointer callData)
/* gets called when one of the drawing areas gets resized */
   {
   Dimension height,
             width;
   Arg al[10];
   int ac;
 
   switch(clientData)
      {
      case TREE:
         {
         /* get new drawing area size */
         ac = 0;
         XtSetArg(al[ac], XmNheight, &(height)); ac++;
         XtSetArg(al[ac], XmNwidth, &(width)); ac++;
         XtGetValues(theWidget, al, ac);
         gWindowYOffset = height - ORGHEIGHTOFTREEDRAWINGAREA;
 
         /* adjust scroll bars */
         ac = 0;
         XtSetArg(al[ac], XmNpageIncrement, width/2); ac++;
         XtSetValues(gTreeHorizontalScroll, al ,ac);
 
         ac = 0;
         XtSetArg(al[ac], XmNpageIncrement, height/2); ac++;
         XtSetValues(gTreeVerticalScroll, al ,ac);
 
         if(XtIsRealized(theWidget))
            {
            XClearArea(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), 0, 0, 0, 0, FALSE);
            DrawTrees();
            }
         break;
         }
      case STACK:
         {
         /* get new drawing area size */
         ac = 0;
         XtSetArg(al[ac], XmNheight, &(height)); ac++;
         XtGetValues(theWidget, al, ac);
         gWindowYOffset = height - ORGHEIGHTOFSTACKDRAWINGAREA;
 
         /* adjust scroll bar */
         ac = 0;
         XtSetArg(al[ac], XmNpageIncrement, height/2); ac++;
         XtSetValues(gStackScroll, al ,ac);
 
         if(XtIsRealized(theWidget))
            {
            DrawStack();
            }
         break;
         }
      default:
         {
         break;
         }
      }
   }

void ScrollCB(Widget theWidget, int clientData, XtPointer callData)
/* gets called when one of the scroll bars gets slid */
   {
   Arg al[10];
   int ac;
   int value;
 
   switch(clientData)
      {
      case TREEHORIZONTAL:
         {
         /* will generate a subsequent expose event */
         XClearArea(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), 0, 0, 0, 0, TRUE);
 
         /* get new scroll bar value and adjust gTreeDrawingXOffset */
         ac = 0;
         XtSetArg(al[ac], XmNvalue, &value); ac++;
         XtGetValues(theWidget, al, ac);
         gTreeDrawingXOffset = value;
         break;
         }
      case TREEVERTICAL:
         {
         /* will generate a subsequent expose event */
         XClearArea(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), 0, 0, 0, 0, TRUE);
 
         /* get new scroll bar value and adjust gTreeDrawingYOffset */
         ac = 0;
         XtSetArg(al[ac], XmNvalue, &value); ac++;
         XtGetValues(theWidget, al, ac);
         gTreeDrawingYOffset = value;
         break;
         }
      case STACKVERTICAL:
         {
         /* will generate a subsequent expose event */
         XClearArea(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), 0, 0, 0, 0, TRUE);
 
         /* get new scroll bar value and adjust gStackDrawingYOffset */
         ac = 0;
         XtSetArg(al[ac], XmNvalue, &value); ac++;
         XtGetValues(theWidget, al, ac);
         gStackDrawingYOffset = value;
         break;
         }
      default:
         {
         break;
         }
      }
   }

void DrawAll(void)
   {
   DrawTrees();
   DrawStack();
   }

void DrawStack(void)
   {
   ParseTreeHdl tree;
   char *s;
   int sLength;
   int count = 0;
   int x1 = LEFTOFSTACK,
       y1,
       x2 = RIGHTOFSTACK,
       y2;
   int stackElementHeight = ORGSTACKELEMENTHEIGHT + (VALUEELEMENTHEIGHT * gNumValues);
   int i;
   int orgValue;
   int valueLength;
   char *valueString = (char *)calloc(30, sizeof(char));
 
   XClearArea(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), 0, 0, 0, 0, FALSE);
   if (gParseTreeList != NULL)
      {
      if (!IsEmpty(gParseTreeList))
         {
         MoveFirst(gParseTreeList);
         while(ExistsFlagged(gParseTreeList)) /* for each element in the "stack"*/
            {
            /* draw a slot to put the element in */
            y1 = BOTTOMOFSTACK - (stackElementHeight * (count + 1));
            y2 = BOTTOMOFSTACK - (stackElementHeight * count);
            XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1, y1 + gWindowYOffset + gStackDrawingYOffset,
                      x1, y2 + gWindowYOffset + gStackDrawingYOffset);
            XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1, y2 + gWindowYOffset + gStackDrawingYOffset,
                      x2, y2 + gWindowYOffset + gStackDrawingYOffset);
            XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x2, y2 + gWindowYOffset + gStackDrawingYOffset,
                      x2, y1 + gWindowYOffset + gStackDrawingYOffset);

            /* draw the element in the slot*/
            tree = FlaggedParseTreeHdl(gParseTreeList);
            /* by getting and drawing it's name*/
            GetParseTreeString(tree, &s, &sLength);
            XDrawString(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1 + STACKSTRINGXOFFSET,
                        (y1 + ORGSTACKELEMENTHEIGHT - STACKSTRINGYOFFSET) + gWindowYOffset + gStackDrawingYOffset,
                        s, sLength);
            /* and by getting and drawing each of it's values*/
            for (i = 0; i < gNumValues; i++) /* for each value */
               {
               orgValue = GetParseTreeOrgValue(tree, i);
               valueLength = sprintf(valueString, "%d", orgValue);
               XDrawString(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1 + STACKSTRINGXOFFSET,
                           y1 + ORGSTACKELEMENTHEIGHT - STACKSTRINGYOFFSET + (VALUEELEMENTHEIGHT * (i + 1)) + gWindowYOffset + gStackDrawingYOffset,
                           valueString, valueLength);
               }

            /* set up for next time through loop*/
            MoveNext(gParseTreeList);
            count++;
            }
         }

      /* draw a slot for one more element at the top so that we can tell that it's the top an not the bottom */
      y1 = BOTTOMOFSTACK - (stackElementHeight * (count + 1));
      y2 = BOTTOMOFSTACK - (stackElementHeight * count);
      XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1, y1 + gWindowYOffset + gStackDrawingYOffset,
                x1, y2 + gWindowYOffset + gStackDrawingYOffset);
      XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x1, y2 + gWindowYOffset + gStackDrawingYOffset,
                x2, y2 + gWindowYOffset + gStackDrawingYOffset);
      XDrawLine(XtDisplay(gStackDrawingArea), XtWindow(gStackDrawingArea), gGC, x2, y2 + gWindowYOffset + gStackDrawingYOffset,
                x2, y1 + gWindowYOffset + gStackDrawingYOffset);
      }
   XFlush(XtDisplay(gStackDrawingArea));
   }

void DrawTrees(void)
   {
   ParseTreeHdl tree;
 
   if (gParseTreeList != NULL)
      {
      if (!IsEmpty(gParseTreeList))
         {
         MoveFirst(gParseTreeList);
         while(ExistsFlagged(gParseTreeList)) /* for each parseTree on the "stack"*/
            {
            tree = FlaggedParseTreeHdl(gParseTreeList);
            DrawParseTree(tree);
            MoveNext(gParseTreeList);
            }
         }
      }
   XFlush(XtDisplay(gTreeDrawingArea));
   }

void DrawParseTree(ParseTreeHdl tree)
   {
   ParseTreeHdl child = GetLeftChild(tree);
   int x, y;
   char *s;
   int sLength;
 
   /* draw the tree's root node */
   GetParseTreePosition(tree, &x, &y);
   GetParseTreeString(tree, &s, &sLength);
   XDrawString(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), gGC, x - gTreeDrawingXOffset,
               y + gWindowYOffset + gTreeDrawingYOffset,
               s, sLength);
   while(child != NULL) /* for each of tree's children */
      {
      /* draw the tree rooted at the child*/
      DrawParseTree(child);
      /* draw the line conecting root to child */
      ConnectNodes(tree, child);

      /* set up for next time throught loop*/
      child = GetRightSib(child);
      }
   }

void ConnectNodes(ParseTreeHdl highNode, ParseTreeHdl lowNode)
   {
   int hx,
       hy,
       lx,
       ly;
 
   GetParseTreePosition(highNode, &hx, &hy);
   GetParseTreePosition(lowNode, &lx, &ly);
   hy = hy +3;
   ly = ly -10;
 
   XDrawLine(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), gGC, hx - gTreeDrawingXOffset, hy + gWindowYOffset + gTreeDrawingYOffset,
             lx - gTreeDrawingXOffset, hy + gWindowYOffset + gTreeDrawingYOffset);
   XDrawLine(XtDisplay(gTreeDrawingArea), XtWindow(gTreeDrawingArea), gGC, lx - gTreeDrawingXOffset, hy + gWindowYOffset + gTreeDrawingYOffset,
             lx - gTreeDrawingXOffset, ly + gWindowYOffset + gTreeDrawingYOffset);
   }