skeleton.c

从lex&yacc说到编译器

    "      yyerrctx->errflag = yyps->errflag;",
    "      yyerrctx->ssp = yyerrctx->ss + (yyps->ssp - yyps->ss);",
    "      yyerrctx->vsp = yyerrctx->vs + (yyps->vsp - yyps->vs);",
    "      yyerrctx->psp = yyerrctx->ps + (yyps->psp - yyps->ps);",
    "      memcpy (yyerrctx->ss, yyps->ss, (yyps->ssp - yyps->ss + 1)*sizeof(Yshort));",
    "      YYSCopy(yyerrctx->vs, yyps->vs, (yyps->ssp - yyps->ss + 1));",
    "      YYPCopy(yyerrctx->ps, yyps->ps, (yyps->ssp - yyps->ss + 1));",
    "      yyerrctx->lexeme = yylvp - yylvals;",
    "    }",
    "    yylvp  = yylvals   + save->lexeme;",
    "    yylpp  = yylpsns   + save->lexeme;",
    "    yylexp = yylexemes + save->lexeme;",
    "    yychar = -1;",
    "    yyps->ssp = yyps->ss + (save->ssp - save->ss);",
    "    yyps->vsp = yyps->vs + (save->vsp - save->vs);",
    "    yyps->psp = yyps->ps + (save->psp - save->ps);",
    "    memcpy (yyps->ss, save->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
    "    YYSCopy(yyps->vs, save->vs,  yyps->vsp - yyps->vs + 1);",
    "    YYPCopy(yyps->ps, save->ps,  yyps->psp - yyps->ps + 1);",
    "    ctry = ++save->ctry;",
    "    yystate = save->state;",
    "    // We tried shift, try reduce now",
    "    if ((yyn = yyctable[ctry]) >= 0) {",
    "      goto yyreduce;",
    "    }",
    "    yyps->save = save->save;",
    "    YYFreeState(save);",
    "    //",
    "    // Nothing left on the stack -- error",
    "    //",
    "    if (!yyps->save) {",
    "#if YYDEBUG",
    "      if (yydebug) {",
    "        printf(\"yydebug[%d]: trial parse FAILED, entering ERROR mode\\n\", ",
    "\t       (int)yytrial);",
    "      }",
    "#endif",
    "      // Restore state as it was in the most forward-advanced error",
    "      yylvp  = yylvals   + yyerrctx->lexeme;",
    "      yylpp  = yylpsns   + yyerrctx->lexeme;",
    "      yylexp = yylexemes + yyerrctx->lexeme;",
    "      yychar = yylexp[-1];",
    "      yylval = yylvp[-1];",
    "      yyposn = yylpp[-1];",
    "      yyps->ssp = yyps->ss + (yyerrctx->ssp - yyerrctx->ss);",
    "      yyps->vsp = yyps->vs + (yyerrctx->vsp - yyerrctx->vs);",
    "      yyps->psp = yyps->ps + (yyerrctx->psp - yyerrctx->ps);",
    "      memcpy (yyps->ss, yyerrctx->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
    "      YYSCopy(yyps->vs, yyerrctx->vs,  yyps->vsp - yyps->vs + 1);",
    "      YYPCopy(yyps->ps, yyerrctx->ps,  yyps->psp - yyps->ps + 1);",
    "      yystate = yyerrctx->state;",
    "      YYFreeState(yyerrctx);",
    "      yyerrctx = NULL;",
    "    }",
    "    yynewerrflag = 1; ",
    "  }",
    "  if (yynewerrflag) {",
    "#ifdef YYERROR_DETAILED",
    "    yyerror_detailed(\"syntax error\", yychar, yylval, yyposn);",
    "#else",
    "    yyerror(\"syntax error\");",
    "#endif",
    "  }",
    "  ++yynerrs;",
    " yyinrecovery:",
    "  if (yyps->errflag < 3) {",
    "    yyps->errflag = 3;",
    "    for (;;) {",
    "      if ((yyn = yysindex[*(yyps->ssp)]) && ",
    "\t  (yyn += YYERRCODE) >= 0 &&",
    "          yyn <= YYTABLESIZE && ",
    "\t  yycheck[yyn] == YYERRCODE) {",
    "#if YYDEBUG",
    "        if (yydebug)",
    "          printf(\"yydebug[%d,%d]: state %d, ERROR recovery shifts to state %d\\n\",",
    "                 yydepth, (int)yytrial, *(yyps->ssp), yytable[yyn]);",
    "#endif",
    "        /* Use label yyerrlab, so that compiler does not warn */",
    "        if(yyps->errflag != yyps->errflag) goto yyerrlab;",
    "        yystate = yytable[yyn];",
    "        goto yyshift; ",
    "      } else {",
    "#if YYDEBUG",
    "        if (yydebug)",
    "          printf(\"yydebug[%d,%d]: ERROR recovery discards state %d\\n\",",
    "                 yydepth, (int)yytrial, *(yyps->ssp));",
    "#endif",
    "        if (yyps->ssp <= yyps->ss) {",
    "\t  goto yyabort;",
    "\t}",
    "\tif(!yytrial) {",
    "\t  YYDELETEVAL(yyps->vsp[0],1);",
    "\t  YYDELETEPOSN(yyps->psp[0],1);",
    "\t}",
    "        --(yyps->ssp);",
    "        --(yyps->vsp);",
    "        --(yyps->psp);",
    "      }",
    "    }",
    "  } else {",
    "    if (yychar == 0) goto yyabort;",
    "#if YYDEBUG",
    "    if (yydebug) {",
    "      yys = 0;",
    "      if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
    "      if (!yys) yys = \"illegal-symbol\";",
    "      printf(\"yydebug[%d,%d]: state %d, ERROR recovery discards token %d (%s)\\n\",",
    "             yydepth, (int)yytrial, yystate, yychar, yys); ",
    "    }",
    "#endif",
    "    if(!yytrial) {",
    "      YYDELETEVAL(yylval,0);",
    "      YYDELETEPOSN(yyposn,0);",
    "    }",
    "    yychar = (-1);",
    "    goto yyloop;",
    "  }",
    "",
    "  //",
    "  // Reduce the rule",
    "  //",
    "yyreduce:",
    "  yym = yylen[yyn];",
    "#if YYDEBUG",
    "  if (yydebug) {",
    "    printf(\"yydebug[%d,%d]: state %d, reducing by rule %d (%s)\",",
    "           yydepth, (int)yytrial, yystate, yyn, yyrule[yyn]);",
    "#ifdef YYDBPR",
    "    if (yym) {",
    "      int i;",
    "      printf(\"<\");",
    "      for (i=yym; i>0; i--) {",
    "        if (i!=yym) printf(\", \");",
    "        YYDBPR((yyps->vsp)[1-i]);",
    "      }",
    "      printf(\">\");",
    "    }",
    "#endif",
    "    printf(\"\\n\");",
    "  }",
    "#endif",
    "  if (yyps->ssp + 1 - yym >= yyps->ss + yyps->stacksize) {",
    "    YYMoreStack(yyps);",
    "  }",
    "",
    "  /* \"$$ = NULL\" default action */",
    "  memset(&yyps->val, 0, sizeof(yyps->val));",
    "",
    "  /* default reduced position is NULL -- no position at all.",
    "     no position will be assigned at trial time and if no position handling is present */",
    "  memset(&yyps->pos, 0, sizeof(yyps->pos));",
    "",
    "  reduce_posn = TRUE;",
    "",
    "  switch (yyn) {",
    "",
    0
};

char *trailer[] =
{
    "#line 567 \"btyaccpa.ske\"",
    "",
    "  default:",
    "    break;",
    "  }",
    "",
    "#if YYDEBUG && defined(YYDBPR)",
    "  if (yydebug) {",
    "    printf(\"yydebug[%d]: after reduction, result is \", yytrial);",
    "    YYDBPR(yyps->val);",
    "    printf(\"\\n\");",
    "  }",
    "#endif",
    "",
    "  // Perform user-defined position reduction",
    "#ifdef YYREDUCEPOSNFUNC",
    "  if(!yytrial) {",
    "    YYCALLREDUCEPOSN(YYREDUCEPOSNFUNCARG);",
    "  }",
    "#endif",
    "",
    "  yyps->ssp -= yym;",
    "  yystate = *(yyps->ssp);",
    "  yyps->vsp -= yym;",
    "  yyps->psp -= yym;",
    "",
    "  yym = yylhs[yyn];",
    "  if (yystate == 0 && yym == 0) {",
    "#if YYDEBUG",
    "    if (yydebug) {",
    "      printf(\"yydebug[%d,%d]: after reduction, shifting from state 0 to state %d\\n\", ",
    "\t     yydepth, (int)yytrial, YYFINAL);",
    "    }",
    "#endif",
    "    yystate = YYFINAL;",
    "    *++(yyps->ssp) = YYFINAL;",
    "    *++(yyps->vsp) = yyps->val;",
    "    yyretlval = yyps->val;\t// return value of root non-terminal to yylval",
    "    *++(yyps->psp) = yyps->pos;",
    "    yyretposn = yyps->pos;\t// return value of root position to yyposn",
    "    if (yychar < 0) {",
    "      if ((yychar = YYLex1()) < 0) {",
    "        yychar = 0;",
    "      }",
    "#if YYDEBUG",
    "      if (yydebug) {",
    "        yys = 0;",
    "        if (yychar <= YYMAXTOKEN) yys = yyname[yychar];",
    "        if (!yys) yys = \"illegal-symbol\";",
    "        printf(\"yydebug[%d,%d]: state %d, reading %d (%s)\\n\", ",
    "\t       yydepth, (int)yytrial, YYFINAL, yychar, yys); ",
    "      }",
    "#endif",
    "    }",
    "    if (yychar == 0) goto yyaccept;",
    "    goto yyloop;",
    "  }",
    "",
    "  if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&",
    "      yyn <= YYTABLESIZE && yycheck[yyn] == yystate) {",
    "    yystate = yytable[yyn];",
    "  } else {",
    "    yystate = yydgoto[yym];",
    "  }",
    "#if YYDEBUG",
    "  if (yydebug)",
    "    printf(\"yydebug[%d,%d]: after reduction, shifting from state %d to state %d\\n\",",
    "           yydepth, (int)yytrial, *(yyps->ssp), yystate);",
    "#endif",
    "  if (yyps->ssp >= yyps->ss + yyps->stacksize - 1) {",
    "    YYMoreStack(yyps);",
    "  }",
    "  *++(yyps->ssp) = yystate;",
    "  *++(yyps->vsp) = yyps->val;",
    "  *++(yyps->psp) = yyps->pos;",
    "  goto yyloop;",
    "",
    "",
    "  //",
    "  // Reduction declares that this path is valid.",
    "  // Set yypath and do a full parse",
    "  //",
    "yyvalid:",
    "  if (yypath) {",
    "    goto yyabort;",
    "  }",
    "  while (yyps->save) {",
    "    yyparsestate *save = yyps->save;",
    "    yyps->save = save->save;",
    "    save->save = yypath;",
    "    yypath = save;",
    "  }",
    "#if YYDEBUG",
    "  if (yydebug)",
    "    printf(\"yydebug[%d,%d]: CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
    "           yydepth, (int)yytrial, yypath->state, yylvp - yylvals - yypath->lexeme);",
    "#endif",
    "  if(yyerrctx) {",
    "    YYFreeState(yyerrctx); yyerrctx = NULL;",
    "  }",
    "  yychar = -1;",
    "  yyps->ssp = yyps->ss + (yypath->ssp - yypath->ss);",
    "  yyps->vsp = yyps->vs + (yypath->vsp - yypath->vs);",
    "  yyps->psp = yyps->ps + (yypath->psp - yypath->ps);",
    "  memcpy (yyps->ss, yypath->ss, (yyps->ssp - yyps->ss + 1) * sizeof(Yshort));",
    "  YYSCopy(yyps->vs, yypath->vs,  yyps->vsp - yyps->vs + 1);",
    "  YYPCopy(yyps->ps, yypath->ps,  yyps->psp - yyps->ps + 1);",
    "  yylvp = yylvals + yypath->lexeme;",
    "  yylpp = yylpsns + yypath->lexeme;",
    "  yylexp = yylexemes + yypath->lexeme;",
    "  yystate = yypath->state;",
    "  goto yyloop;",
    "",
    "",
    "yyabort:",
    "  if(yyerrctx) {",
    "    YYFreeState(yyerrctx); yyerrctx = NULL;",
    "  }",
    "",
    "  YYSTYPE *pv;",
    "  for(pv=yyps->vs; pv<yyps->vsp; pv++) {",
    "    YYDELETEVAL(*pv,2);",
    "  }",
    "",
    "  YYPOSN *pp;",
    "  for(pp=yyps->ps; pp<yyps->psp; pp++) {",
    "    YYDELETEPOSN(*pp,2);",
    "  }",
    "",
    "  while (yyps) {",
    "    yyparsestate *save = yyps;",
    "    yyps = save->save;",
    "    YYFreeState(save);",
    "  }",
    "  while (yypath) {",
    "    yyparsestate *save = yypath;",
    "    yypath = save->save;",
    "    YYFreeState(save); ",
    "  }",
    "  return (1);",
    "",
    "",
    "yyaccept:",
    "  if (yyps->save) goto yyvalid;",
    "  if(yyerrctx) {",
    "    YYFreeState(yyerrctx); yyerrctx = NULL;",
    "  }",
    "  while (yyps) {",
    "    yyparsestate *save = yyps;",
    "    yyps = save->save;",
    "    YYFreeState(save);",
    "  }",
    "  while (yypath) {",
    "    yyparsestate *save = yypath;",
    "    yypath = save->save;",
    "    YYFreeState(save); ",
    "  }",
    "  return (0);",
    "}",
    "",
    "",
    "int YYLex1() {",
    "  if(yylvp<yylve) {",
    "    yylval = *yylvp++;",
    "    yyposn = *yylpp++;",
    "    return *yylexp++;",
    "  } else {",
    "    if(yyps->save) {",
    "      if(yylvp==yylvlim) {",
    "\tyyexpand();",
    "      }",
    "      *yylexp = yylex();",
    "      *yylvp++ = yylval;",
    "      yylve++;",
    "      *yylpp++ = yyposn;",
    "      yylpe++;",
    "      return *yylexp++;",
    "    } else {",
    "      return yylex();",
    "    }",
    "  }",
    "}",
    "",
    "int yyexpand() {",
    "  int p = yylvp-yylvals;",
    "  int s = yylvlim-yylvals;",
    "  s += YYSTACKGROWTH;",
    "  { Yshort  *tl = yylexemes; ",
    "    YYSTYPE *tv = yylvals;",
    "    YYPOSN  *tp = yylpsns;",
    "    yylvals = new YYSTYPE[s];",
    "    yylpsns = new YYPOSN[s];",
    "    yylexemes = new Yshort[s];",
    "    memcpy(yylexemes, tl, (s-YYSTACKGROWTH)*sizeof(Yshort));",
    "    YYSCopy(yylvals, tv, s-YYSTACKGROWTH);",
    "    YYPCopy(yylpsns, tp, s-YYSTACKGROWTH);",
    "    delete[] tl;",
    "    delete[] tv;",
    "    delete[] tp;",
    "  }",
    "  yylvp = yylve = yylvals + p;",
    "  yylvlim = yylvals + s;",
    "  yylpp = yylpe = yylpsns + p;",
    "  yylplim = yylpsns + s;",
    "  yylexp = yylexemes + p;",
    "  return 0;",
    "}",
    "",
    "void YYSCopy(YYSTYPE *to, YYSTYPE *from, int size) {",
    "  int i;                             ",
    "  for (i = size-1; i >= 0; i--) {",
    "    to[i] = from[i];",
    "  }",
    "}",
    "",
    "void YYPCopy(YYPOSN *to, YYPOSN *from, int size) {",
    "  int i;                             ",
    "  for (i = size-1; i >= 0; i--) {",
    "    to[i] = from[i];",
    "  }",
    "}",
    "",
    "void YYMoreStack(yyparsestate *yyps) {",
    "  int p = yyps->ssp - yyps->ss;                               ",
    "  Yshort  *tss = yyps->ss;",
    "  YYSTYPE *tvs = yyps->vs;",
    "  YYPOSN  *tps = yyps->ps;",
    "  yyps->ss = new Yshort [yyps->stacksize + YYSTACKGROWTH];   ",
    "  yyps->vs = new YYSTYPE[yyps->stacksize + YYSTACKGROWTH];  ",
    "  yyps->ps = new YYPOSN [yyps->stacksize + YYSTACKGROWTH];  ",
    "  memcpy(yyps->ss, tss, yyps->stacksize * sizeof(Yshort));  ",
    "  YYSCopy(yyps->vs, tvs, yyps->stacksize);                  ",
    "  YYPCopy(yyps->ps, tps, yyps->stacksize);                  ",
    "  yyps->stacksize += YYSTACKGROWTH;                           ",
    "  delete[] tss;",
    "  delete[] tvs;",
    "  delete[] tps;",
    "  yyps->ssp = yyps->ss + p;                                   ",
    "  yyps->vsp = yyps->vs + p;                                   ",
    "  yyps->psp = yyps->ps + p;                                   ",
    "}",
    "",
    "yyparsestate *YYNewState(int size) {",
    "  yyparsestate *p = new yyparsestate;",
    "  p->stacksize = size+4;",
    "  p->ss = new Yshort [size + 4];",
    "  p->vs = new YYSTYPE[size + 4];",
    "  p->ps = new YYPOSN [size + 4];",
    "  memset(&p->vs[0], 0, (size+4)*sizeof(YYSTYPE));",
    "  memset(&p->ps[0], 0, (size+4)*sizeof(YYPOSN));",
    "  return p;",
    "}",
    "",
    "void YYFreeState(yyparsestate *p) {",
    "  delete[] p->ss;",
    "  delete[] p->vs;",
    "  delete[] p->ps;",
    "  delete p;",
    "}",
    0
};

struct section section_list[] = {
	{ "banner", &banner[0] },
	{ "tables", &tables[0] },
	{ "header", &header[0] },
	{ "body", &body[0] },
	{ "trailer", &trailer[0] },
	{ 0, 0 } };