The Machine Perception Toolbox (MPT)

01010 {
01011   
01012   register int yystate;
01013   register int yyn;
01014   int yyresult;
01015   /* Number of tokens to shift before error messages enabled.  */
01016   int yyerrstatus;
01017   /* Lookahead token as an internal (translated) token number.  */
01018   int yytoken = 0;
01019 
01020   /* Three stacks and their tools:
01021      `yyss': related to states,
01022      `yyvs': related to semantic values,
01023      `yyls': related to locations.
01024 
01025      Refer to the stacks thru separate pointers, to allow yyoverflow
01026      to reallocate them elsewhere.  */
01027 
01028   /* The state stack.  */
01029   short yyssa[YYINITDEPTH];
01030   short *yyss = yyssa;
01031   register short *yyssp;
01032 
01033   /* The semantic value stack.  */
01034   YYSTYPE yyvsa[YYINITDEPTH];
01035   YYSTYPE *yyvs = yyvsa;
01036   register YYSTYPE *yyvsp;
01037 
01038 
01039 
01040 #define YYPOPSTACK   (yyvsp--, yyssp--)
01041 
01042   YYSIZE_T yystacksize = YYINITDEPTH;
01043 
01044   /* The variables used to return semantic value and location from the
01045      action routines.  */
01046   YYSTYPE yyval;
01047 
01048 
01049   /* When reducing, the number of symbols on the RHS of the reduced
01050      rule.  */
01051   int yylen;
01052 
01053   YYDPRINTF ((stderr, "Starting parse\n"));
01054 
01055   yystate = 0;
01056   yyerrstatus = 0;
01057   yynerrs = 0;
01058   yychar = YYEMPTY;             /* Cause a token to be read.  */
01059 
01060   /* Initialize stack pointers.
01061      Waste one element of value and location stack
01062      so that they stay on the same level as the state stack.
01063      The wasted elements are never initialized.  */
01064 
01065   yyssp = yyss;
01066   yyvsp = yyvs;
01067 
01068   goto yysetstate;
01069 
01070 /*------------------------------------------------------------.
01071 | yynewstate -- Push a new state, which is found in yystate.  |
01072 `------------------------------------------------------------*/
01073  yynewstate:
01074   /* In all cases, when you get here, the value and location stacks
01075      have just been pushed. so pushing a state here evens the stacks.
01076      */
01077   yyssp++;
01078 
01079  yysetstate:
01080   *yyssp = yystate;
01081 
01082   if (yyss + yystacksize - 1 <= yyssp)
01083     {
01084       /* Get the current used size of the three stacks, in elements.  */
01085       YYSIZE_T yysize = yyssp - yyss + 1;
01086 
01087 #ifdef yyoverflow
01088       {
01089         /* Give user a chance to reallocate the stack. Use copies of
01090            these so that the &'s don't force the real ones into
01091            memory.  */
01092         YYSTYPE *yyvs1 = yyvs;
01093         short *yyss1 = yyss;
01094 
01095 
01096         /* Each stack pointer address is followed by the size of the
01097            data in use in that stack, in bytes.  This used to be a
01098            conditional around just the two extra args, but that might
01099            be undefined if yyoverflow is a macro.  */
01100         yyoverflow ("parser stack overflow",
01101                     &yyss1, yysize * sizeof (*yyssp),
01102                     &yyvs1, yysize * sizeof (*yyvsp),
01103 
01104                     &yystacksize);
01105 
01106         yyss = yyss1;
01107         yyvs = yyvs1;
01108       }
01109 #else /* no yyoverflow */
01110 # ifndef YYSTACK_RELOCATE
01111       goto yyoverflowlab;
01112 # else
01113       /* Extend the stack our own way.  */
01114       if (YYMAXDEPTH <= yystacksize)
01115         goto yyoverflowlab;
01116       yystacksize *= 2;
01117       if (YYMAXDEPTH < yystacksize)
01118         yystacksize = YYMAXDEPTH;
01119 
01120       {
01121         short *yyss1 = yyss;
01122         union yyalloc *yyptr =
01123           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01124         if (! yyptr)
01125           goto yyoverflowlab;
01126         YYSTACK_RELOCATE (yyss);
01127         YYSTACK_RELOCATE (yyvs);
01128 
01129 #  undef YYSTACK_RELOCATE
01130         if (yyss1 != yyssa)
01131           YYSTACK_FREE (yyss1);
01132       }
01133 # endif
01134 #endif /* no yyoverflow */
01135 
01136       yyssp = yyss + yysize - 1;
01137       yyvsp = yyvs + yysize - 1;
01138 
01139 
01140       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01141                   (unsigned long int) yystacksize));
01142 
01143       if (yyss + yystacksize - 1 <= yyssp)
01144         YYABORT;
01145     }
01146 
01147   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01148 
01149   goto yybackup;
01150 
01151 /*-----------.
01152 | yybackup.  |
01153 `-----------*/
01154 yybackup:
01155 
01156 /* Do appropriate processing given the current state.  */
01157 /* Read a lookahead token if we need one and don't already have one.  */
01158 /* yyresume: */
01159 
01160   /* First try to decide what to do without reference to lookahead token.  */
01161 
01162   yyn = yypact[yystate];
01163   if (yyn == YYPACT_NINF)
01164     goto yydefault;
01165 
01166   /* Not known => get a lookahead token if don't already have one.  */
01167 
01168   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01169   if (yychar == YYEMPTY)
01170     {
01171       YYDPRINTF ((stderr, "Reading a token: "));
01172       yychar = YYLEX;
01173     }
01174 
01175   if (yychar <= YYEOF)
01176     {
01177       yychar = yytoken = YYEOF;
01178       YYDPRINTF ((stderr, "Now at end of input.\n"));
01179     }
01180   else
01181     {
01182       yytoken = YYTRANSLATE (yychar);
01183       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
01184     }
01185 
01186   /* If the proper action on seeing token YYTOKEN is to reduce or to
01187      detect an error, take that action.  */
01188   yyn += yytoken;
01189   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01190     goto yydefault;
01191   yyn = yytable[yyn];
01192   if (yyn <= 0)
01193     {
01194       if (yyn == 0 || yyn == YYTABLE_NINF)
01195         goto yyerrlab;
01196       yyn = -yyn;
01197       goto yyreduce;
01198     }
01199 
01200   if (yyn == YYFINAL)
01201     YYACCEPT;
01202 
01203   /* Shift the lookahead token.  */
01204   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
01205 
01206   /* Discard the token being shifted unless it is eof.  */
01207   if (yychar != YYEOF)
01208     yychar = YYEMPTY;
01209 
01210   *++yyvsp = yylval;
01211 
01212 
01213   /* Count tokens shifted since error; after three, turn off error
01214      status.  */
01215   if (yyerrstatus)
01216     yyerrstatus--;
01217 
01218   yystate = yyn;
01219   goto yynewstate;
01220 
01221 
01222 /*-----------------------------------------------------------.
01223 | yydefault -- do the default action for the current state.  |
01224 `-----------------------------------------------------------*/
01225 yydefault:
01226   yyn = yydefact[yystate];
01227   if (yyn == 0)
01228     goto yyerrlab;
01229   goto yyreduce;
01230 
01231 
01232 /*-----------------------------.
01233 | yyreduce -- Do a reduction.  |
01234 `-----------------------------*/
01235 yyreduce:
01236   /* yyn is the number of a rule to reduce with.  */
01237   yylen = yyr2[yyn];
01238 
01239   /* If YYLEN is nonzero, implement the default value of the action:
01240      `$$ = $1'.
01241 
01242      Otherwise, the following line sets YYVAL to garbage.
01243      This behavior is undocumented and Bison
01244      users should not rely upon it.  Assigning to YYVAL
01245      unconditionally makes the parser a bit smaller, and it avoids a
01246      GCC warning that YYVAL may be used uninitialized.  */
01247   yyval = yyvsp[1-yylen];
01248 
01249 
01250   YY_REDUCE_PRINT (yyn);
01251   switch (yyn)
01252     {
01253         case 3:
01254 #line 144 "jamgram.y"
01255     { parse_save( yyvsp[0].parse ); }
01256     break;
01257 
01258   case 4:
01259 #line 155 "jamgram.y"
01260     { yyval.parse = yyvsp[0].parse; }
01261     break;
01262 
01263   case 5:
01264 #line 157 "jamgram.y"
01265     { yyval.parse = yyvsp[0].parse; }
01266     break;
01267 
01268   case 6:
01269 #line 161 "jamgram.y"
01270     { yyval.parse = yyvsp[0].parse; }
01271     break;
01272 
01273   case 7:
01274 #line 163 "jamgram.y"
01275     { yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
01276     break;
01277 
01278   case 8:
01279 #line 165 "jamgram.y"
01280     { yyval.parse = plocal( yyvsp[-3].parse, yyvsp[-2].parse, yyvsp[0].parse ); }
01281     break;
01282 
01283   case 9:
01284 #line 169 "jamgram.y"
01285     { yyval.parse = pnull(); }
01286     break;
01287 
01288   case 10:
01289 #line 173 "jamgram.y"
01290     { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_SET; }
01291     break;
01292 
01293   case 11:
01294 #line 175 "jamgram.y"
01295     { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_APPEND; }
01296     break;
01297 
01298   case 12:
01299 #line 179 "jamgram.y"
01300     { yyval.parse = yyvsp[-1].parse; }
01301     break;
01302 
01303   case 13:
01304 #line 181 "jamgram.y"
01305     { yyval.parse = P0; }
01306     break;
01307 
01308   case 14:
01309 #line 185 "jamgram.y"
01310     { yyval.number = 1; }
01311     break;
01312 
01313   case 15:
01314 #line 187 "jamgram.y"
01315     { yyval.number = 0; }
01316     break;
01317 
01318   case 16:
01319 #line 191 "jamgram.y"
01320     { yyval.parse = yyvsp[-1].parse; }
01321     break;
01322 
01323   case 17:
01324 #line 193 "jamgram.y"
01325     { yyval.parse = pincl( yyvsp[-1].parse ); }
01326     break;
01327 
01328   case 18:
01329 #line 195 "jamgram.y"
01330     { yyval.parse = prule( yyvsp[-2].string, yyvsp[-1].parse ); }
01331     break;
01332 
01333   case 19:
01334 #line 197 "jamgram.y"
01335     { yyval.parse = pset( yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
01336     break;
01337 
01338   case 20:
01339 #line 199 "jamgram.y"
01340     { yyval.parse = pset1( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
01341     break;
01342 
01343   case 21:
01344 #line 201 "jamgram.y"
01345     { yyval.parse = yyvsp[-1].parse; }
01346     break;
01347 
01348   case 22:
01349 #line 203 "jamgram.y"
01350     { yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-6].number ); }
01351     break;
01352 
01353   case 23:
01354 #line 205 "jamgram.y"
01355     { yyval.parse = pswitch( yyvsp[-3].parse, yyvsp[-1].parse ); }
01356     break;
01357 
01358   case 24:
01359 #line 207 "jamgram.y"
01360     { yyval.parse = pif( yyvsp[-3].parse, yyvsp[-1].parse, pnull() ); }
01361     break;
01362 
01363   case 25:
01364 #line 209 "jamgram.y"
01365     { yyval.parse = pmodule( yyvsp[-3].parse, yyvsp[-1].parse ); }
01366     break;
01367 
01368   case 26:
01369 #line 211 "jamgram.y"
01370     { yyval.parse = pclass( yyvsp[-3].parse, yyvsp[-1].parse ); }
01371     break;
01372 
01373   case 27:
01374 #line 213 "jamgram.y"
01375     { yyval.parse = pwhile( yyvsp[-3].parse, yyvsp[-1].parse ); }
01376     break;
01377 
01378   case 28:
01379 #line 215 "jamgram.y"
01380     { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
01381     break;
01382 
01383   case 29:
01384 #line 217 "jamgram.y"
01385     { yyval.parse = psetc( yyvsp[-2].string, yyvsp[0].parse, yyvsp[-1].parse, yyvsp[-4].number ); }
01386     break;
01387 
01388   case 30:
01389 #line 219 "jamgram.y"
01390     { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
01391     break;
01392 
01393   case 31:
01394 #line 221 "jamgram.y"
01395     { yymode( SCAN_STRING ); }
01396     break;
01397 
01398   case 32:
01399 #line 223 "jamgram.y"
01400     { yymode( SCAN_NORMAL ); }
01401     break;
01402 
01403   case 33:
01404 #line 225 "jamgram.y"
01405     { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
01406     break;
01407 
01408   case 34:
01409 #line 233 "jamgram.y"
01410     { yyval.number = ASSIGN_SET; }
01411     break;
01412 
01413   case 35:
01414 #line 235 "jamgram.y"
01415     { yyval.number = ASSIGN_APPEND; }
01416     break;
01417 
01418   case 36:
01419 #line 237 "jamgram.y"
01420     { yyval.number = ASSIGN_DEFAULT; }
01421     break;
01422 
01423   case 37:
01424 #line 239 "jamgram.y"
01425     { yyval.number = ASSIGN_DEFAULT; }
01426     break;
01427 
01428   case 38:
01429 #line 246 "jamgram.y"
01430     { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); }
01431     break;
01432 
01433   case 39:
01434 #line 248 "jamgram.y"
01435     { yyval.parse = peval( EXPR_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); }
01436     break;
01437 
01438   case 40:
01439 #line 250 "jamgram.y"
01440     { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
01441     break;
01442 
01443   case 41:
01444 #line 252 "jamgram.y"
01445     { yyval.parse = peval( EXPR_LESS, yyvsp[-2].parse, yyvsp[0].parse ); }
01446     break;
01447 
01448   case 42:
01449 #line 254 "jamgram.y"
01450     { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
01451     break;
01452 
01453   case 43:
01454 #line 256 "jamgram.y"
01455     { yyval.parse = peval( EXPR_MORE, yyvsp[-2].parse, yyvsp[0].parse ); }
01456     break;
01457 
01458   case 44:
01459 #line 258 "jamgram.y"
01460     { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
01461     break;
01462 
01463   case 45:
01464 #line 260 "jamgram.y"
01465     { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
01466     break;
01467 
01468   case 46:
01469 #line 262 "jamgram.y"
01470     { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
01471     break;
01472 
01473   case 47:
01474 #line 264 "jamgram.y"
01475     { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
01476     break;
01477 
01478   case 48:
01479 #line 266 "jamgram.y"
01480     { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
01481     break;
01482 
01483   case 49:
01484 #line 268 "jamgram.y"
01485     { yyval.parse = peval( EXPR_IN, yyvsp[-2].parse, yyvsp[0].parse ); }
01486     break;
01487 
01488   case 50:
01489 #line 270 "jamgram.y"
01490     { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
01491     break;
01492 
01493   case 51:
01494 #line 272 "jamgram.y"
01495     { yyval.parse = yyvsp[-1].parse; }
01496     break;
01497 
01498   case 52:
01499 #line 283 "jamgram.y"
01500     { yyval.parse = P0; }
01501     break;
01502 
01503   case 53:
01504 #line 285 "jamgram.y"
01505     { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
01506     break;
01507 
01508   case 54:
01509 #line 289 "jamgram.y"
01510     { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
01511     break;
01512 
01513   case 55:
01514 #line 298 "jamgram.y"
01515     { yyval.parse = pnode( P0, yyvsp[0].parse ); }
01516     break;
01517 
01518   case 56:
01519 #line 300 "jamgram.y"
01520     { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
01521     break;
01522 
01523   case 57:
01524 #line 310 "jamgram.y"
01525     { yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); }
01526     break;
01527 
01528   case 58:
01529 #line 314 "jamgram.y"
01530     { yyval.parse = pnull(); yymode( SCAN_PUNCT ); }
01531     break;
01532 
01533   case 59:
01534 #line 316 "jamgram.y"
01535     { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
01536     break;
01537 
01538   case 60:
01539 #line 320 "jamgram.y"
01540     { yyval.parse = plist( yyvsp[0].string ); }
01541     break;
01542 
01543   case 61:
01544 #line 321 "jamgram.y"
01545     { yymode( SCAN_NORMAL ); }
01546     break;
01547 
01548   case 62:
01549 #line 322 "jamgram.y"
01550     { yyval.parse = yyvsp[-1].parse; }
01551     break;
01552 
01553   case 63:
01554 #line 331 "jamgram.y"
01555     { yyval.parse = prule( yyvsp[-1].string, yyvsp[0].parse ); }
01556     break;
01557 
01558   case 64:
01559 #line 333 "jamgram.y"
01560     { yyval.parse = pon( yyvsp[-2].parse, prule( yyvsp[-1].string, yyvsp[0].parse ) ); }
01561     break;
01562 
01563   case 65:
01564 #line 335 "jamgram.y"
01565     { yyval.parse = pon( yyvsp[-2].parse, yyvsp[0].parse ); }
01566     break;
01567 
01568   case 66:
01569 #line 345 "jamgram.y"
01570     { yyval.number = 0; }
01571     break;
01572 
01573   case 67:
01574 #line 347 "jamgram.y"
01575     { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
01576     break;
01577 
01578   case 68:
01579 #line 351 "jamgram.y"
01580     { yyval.number = EXEC_UPDATED; }
01581     break;
01582 
01583   case 69:
01584 #line 353 "jamgram.y"
01585     { yyval.number = EXEC_TOGETHER; }
01586     break;
01587 
01588   case 70:
01589 #line 355 "jamgram.y"
01590     { yyval.number = EXEC_IGNORE; }
01591     break;
01592 
01593   case 71:
01594 #line 357 "jamgram.y"
01595     { yyval.number = EXEC_QUIETLY; }
01596     break;
01597 
01598   case 72:
01599 #line 359 "jamgram.y"
01600     { yyval.number = EXEC_PIECEMEAL; }
01601     break;
01602 
01603   case 73:
01604 #line 361 "jamgram.y"
01605     { yyval.number = EXEC_EXISTING; }
01606     break;
01607 
01608   case 74:
01609 #line 370 "jamgram.y"
01610     { yyval.parse = pnull(); }
01611     break;
01612 
01613   case 75:
01614 #line 372 "jamgram.y"
01615     { yyval.parse = yyvsp[0].parse; }
01616     break;
01617 
01618 
01619     }
01620 
01621 /* Line 999 of yacc.c.  */
01622 #line 1623 "y.tab.c"
01623 
01624   yyvsp -= yylen;
01625   yyssp -= yylen;
01626 
01627 
01628   YY_STACK_PRINT (yyss, yyssp);
01629 
01630   *++yyvsp = yyval;
01631 
01632 
01633   /* Now `shift' the result of the reduction.  Determine what state
01634      that goes to, based on the state we popped back to and the rule
01635      number reduced by.  */
01636 
01637   yyn = yyr1[yyn];
01638 
01639   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01640   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01641     yystate = yytable[yystate];
01642   else
01643     yystate = yydefgoto[yyn - YYNTOKENS];
01644 
01645   goto yynewstate;
01646 
01647 
01648 /*------------------------------------.
01649 | yyerrlab -- here on detecting error |
01650 `------------------------------------*/
01651 yyerrlab:
01652   /* If not already recovering from an error, report this error.  */
01653   if (!yyerrstatus)
01654     {
01655       ++yynerrs;
01656 #if YYERROR_VERBOSE
01657       yyn = yypact[yystate];
01658 
01659       if (YYPACT_NINF < yyn && yyn < YYLAST)
01660         {
01661           YYSIZE_T yysize = 0;
01662           int yytype = YYTRANSLATE (yychar);
01663           char *yymsg;
01664           int yyx, yycount;
01665 
01666           yycount = 0;
01667           /* Start YYX at -YYN if negative to avoid negative indexes in
01668              YYCHECK.  */
01669           for (yyx = yyn < 0 ? -yyn : 0;
01670                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
01671             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01672               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
01673           yysize += yystrlen ("syntax error, unexpected ") + 1;
01674           yysize += yystrlen (yytname[yytype]);
01675           yymsg = (char *) YYSTACK_ALLOC (yysize);
01676           if (yymsg != 0)
01677             {
01678               char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
01679               yyp = yystpcpy (yyp, yytname[yytype]);
01680 
01681               if (yycount < 5)
01682                 {
01683                   yycount = 0;
01684                   for (yyx = yyn < 0 ? -yyn : 0;
01685                        yyx < (int) (sizeof (yytname) / sizeof (char *));
01686                        yyx++)
01687                     if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01688                       {
01689                         const char *yyq = ! yycount ? ", expecting " : " or ";
01690                         yyp = yystpcpy (yyp, yyq);
01691                         yyp = yystpcpy (yyp, yytname[yyx]);
01692                         yycount++;
01693                       }
01694                 }
01695               yyerror (yymsg);
01696               YYSTACK_FREE (yymsg);
01697             }
01698           else
01699             yyerror ("syntax error; also virtual memory exhausted");
01700         }
01701       else
01702 #endif /* YYERROR_VERBOSE */
01703         yyerror ("syntax error");
01704     }
01705 
01706 
01707 
01708   if (yyerrstatus == 3)
01709     {
01710       /* If just tried and failed to reuse lookahead token after an
01711          error, discard it.  */
01712 
01713       /* Return failure if at end of input.  */
01714       if (yychar == YYEOF)
01715         {
01716           /* Pop the error token.  */
01717           YYPOPSTACK;
01718           /* Pop the rest of the stack.  */
01719           while (yyss < yyssp)
01720             {
01721               YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
01722               yydestruct (yystos[*yyssp], yyvsp);
01723               YYPOPSTACK;
01724             }
01725           YYABORT;
01726         }
01727 
01728       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
01729       yydestruct (yytoken, &yylval);
01730       yychar = YYEMPTY;
01731 
01732     }
01733 
01734   /* Else will try to reuse lookahead token after shifting the error
01735      token.  */
01736   goto yyerrlab1;
01737 
01738 
01739 /*----------------------------------------------------.
01740 | yyerrlab1 -- error raised explicitly by an action.  |
01741 `----------------------------------------------------*/
01742 yyerrlab1:
01743   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
01744 
01745   for (;;)
01746     {
01747       yyn = yypact[yystate];
01748       if (yyn != YYPACT_NINF)
01749         {
01750           yyn += YYTERROR;
01751           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01752             {
01753               yyn = yytable[yyn];
01754               if (0 < yyn)
01755                 break;
01756             }
01757         }
01758 
01759       /* Pop the current state because it cannot handle the error token.  */
01760       if (yyssp == yyss)
01761         YYABORT;
01762 
01763       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
01764       yydestruct (yystos[yystate], yyvsp);
01765       yyvsp--;
01766       yystate = *--yyssp;
01767 
01768       YY_STACK_PRINT (yyss, yyssp);
01769     }
01770 
01771   if (yyn == YYFINAL)
01772     YYACCEPT;
01773 
01774   YYDPRINTF ((stderr, "Shifting error token, "));
01775 
01776   *++yyvsp = yylval;
01777 
01778 
01779   yystate = yyn;
01780   goto yynewstate;
01781 
01782 
01783 /*-------------------------------------.
01784 | yyacceptlab -- YYACCEPT comes here.  |
01785 `-------------------------------------*/
01786 yyacceptlab:
01787   yyresult = 0;
01788   goto yyreturn;
01789 
01790 /*-----------------------------------.
01791 | yyabortlab -- YYABORT comes here.  |
01792 `-----------------------------------*/
01793 yyabortlab:
01794   yyresult = 1;
01795   goto yyreturn;
01796 
01797 #ifndef yyoverflow
01798 /*----------------------------------------------.
01799 | yyoverflowlab -- parser overflow comes here.  |
01800 `----------------------------------------------*/
01801 yyoverflowlab:
01802   yyerror ("parser stack overflow");
01803   yyresult = 2;
01804   /* Fall through.  */
01805 #endif
01806 
01807 yyreturn:
01808 #ifndef yyoverflow
01809   if (yyss != yyssa)
01810     YYSTACK_FREE (yyss);
01811 #endif
01812   return yyresult;
01813 }


Classes
union	yyalloc
Defines
#define	_AMPER_t 260
#define	_AMPERAMPER_t 261
#define	_BANG_EQUALS_t 259
#define	_BANG_t 258
#define	_BAR_t 299
#define	_BARBAR_t 300
#define	_COLON_t 265
#define	_EQUALS_t 269
#define	_LANGLE_EQUALS_t 268
#define	_LANGLE_t 267
#define	_LBRACE_t 298
#define	_LBRACKET_t 273
#define	_LPAREN_t 262
#define	_PLUS_EQUALS_t 264
#define	_QUESTION_EQUALS_t 272
#define	_RANGLE_EQUALS_t 271
#define	_RANGLE_t 270
#define	_RBRACE_t 301
#define	_RBRACKET_t 274
#define	_RPAREN_t 263
#define	_SEMIC_t 266
#define	ACTIONS_t 275
#define	ARG 302
#define	BIND_t 276
#define	CASE_t 277
#define	CLASS_t 278
#define	DEFAULT_t 279
#define	ELSE_t 280
#define	EXISTING_t 281
#define	F0 (LIST ()(PARSE , FRAME ))0
#define	FOR_t 282
#define	IF_t 283
#define	IGNORE_t 284
#define	IN_t 285
#define	INCLUDE_t 286
#define	LOCAL_t 287
#define	MODULE_t 288
#define	ON_t 289
#define	P0 (PARSE *)0
#define	pappend(l, r) parse_make( compile_append,l,r,P0,S0,S0,0 )
#define	pclass(l, r) parse_make( compile_class,l,r,P0,S0,S0,0 )
#define	peval(c, l, r) parse_make( compile_eval,l,r,P0,S0,S0,c )
#define	pfor(s, l, r, x) parse_make( compile_foreach,l,r,P0,s,S0,x )
#define	PIECEMEAL_t 290
#define	pif(l, r, t) parse_make( compile_if,l,r,t,S0,S0,0 )
#define	pincl(l) parse_make( compile_include,l,P0,P0,S0,S0,0 )
#define	plist(s) parse_make( compile_list,P0,P0,P0,s,S0,0 )
#define	plocal(l, r, t) parse_make( compile_local,l,r,t,S0,S0,0 )
#define	pmodule(l, r) parse_make( compile_module,l,r,P0,S0,S0,0 )
#define	pnode(l, r) parse_make( F0,l,r,P0,S0,S0,0 )
#define	pnull() parse_make( compile_null,P0,P0,P0,S0,S0,0 )
#define	pon(l, r) parse_make( compile_on,l,r,P0,S0,S0,0 )
#define	prule(s, p) parse_make( compile_rule,p,P0,P0,s,S0,0 )
#define	prules(l, r) parse_make( compile_rules,l,r,P0,S0,S0,0 )
#define	pset(l, r, a) parse_make( compile_set,l,r,P0,S0,S0,a )
#define	pset1(l, r, t, a) parse_make( compile_settings,l,r,t,S0,S0,a )
#define	psetc(s, p, a, l) parse_make( compile_setcomp,p,a,P0,s,S0,l )
#define	psete(s, l, s1, f) parse_make( compile_setexec,l,P0,P0,s,s1,f )
#define	psnode(s, l) parse_make( F0,l,P0,P0,s,S0,0 )
#define	pswitch(l, r) parse_make( compile_switch,l,r,P0,S0,S0,0 )
#define	pwhile(l, r) parse_make( compile_while,l,r,P0,S0,S0,0 )
#define	QUIETLY_t 291
#define	RETURN_t 292
#define	RULE_t 293
#define	S0 (char *)0
#define	STRING 303
#define	SWITCH_t 294
#define	TOGETHER_t 295
#define	UPDATED_t 296
#define	WHILE_t 297
#define	YY_REDUCE_PRINT(Rule)
#define	YY_STACK_PRINT(Bottom, Top)
#define	YYABORT goto yyabortlab
#define	YYACCEPT goto yyacceptlab
#define	YYBACKUP(Token, Value)
#define	YYBISON 1
#define	yyclearin (yychar = YYEMPTY)
#define	YYCOPY(To, From, Count)
#define	YYDEBUG 0
#define	YYDPRINTF(Args)
#define	YYDSYMPRINT(Args)
#define	YYDSYMPRINTF(Title, Token, Value, Location)
#define	YYEMPTY (-2)
#define	YYEOF 0
#define	YYERRCODE 256
#define	yyerrok (yyerrstatus = 0)
#define	YYERROR goto yyerrlab1
#define	YYERROR_VERBOSE 0
#define	YYFAIL goto yyerrlab
#define	YYFINAL 43
#define	YYINITDEPTH 200
#define	YYLAST 261
#define	YYLEX yylex ()
#define	YYLLOC_DEFAULT(Current, Rhs, N)
#define	YYLSP_NEEDED 0
#define	YYMAXDEPTH 10000
#define	YYMAXUTOK 303
#define	YYNNTS 24
#define	YYNRULES 75
#define	YYNSTATES 159
#define	YYNTOKENS 49
#define	YYPACT_NINF -48
#define	YYPOPSTACK (yyvsp--, yyssp--)
#define	YYPURE 0
#define	YYRECOVERING() (!!yyerrstatus)
#define	YYSIZE_T unsigned int
#define	YYSKELETON_NAME "yacc.c"
#define	YYSTACK_ALLOC malloc
#define	YYSTACK_BYTES(N)
#define	YYSTACK_FREE free
#define	YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
#define	YYSTACK_RELOCATE(Stack)
#define	YYTABLE_NINF -59
#define	YYTERROR 1
#define	YYTRANSLATE(YYX) ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define	YYUNDEFTOK 2
Typedefs
typedef short	yysigned_char
Enumerations
enum	yytokentype { _BANG_t = 258, _BANG_EQUALS_t = 259, _AMPER_t = 260, _AMPERAMPER_t = 261, _LPAREN_t = 262, _RPAREN_t = 263, _PLUS_EQUALS_t = 264, _COLON_t = 265, _SEMIC_t = 266, _LANGLE_t = 267, _LANGLE_EQUALS_t = 268, _EQUALS_t = 269, _RANGLE_t = 270, _RANGLE_EQUALS_t = 271, _QUESTION_EQUALS_t = 272, _LBRACKET_t = 273, _RBRACKET_t = 274, ACTIONS_t = 275, BIND_t = 276, CASE_t = 277, CLASS_t = 278, DEFAULT_t = 279, ELSE_t = 280, EXISTING_t = 281, FOR_t = 282, IF_t = 283, IGNORE_t = 284, IN_t = 285, INCLUDE_t = 286, LOCAL_t = 287, MODULE_t = 288, ON_t = 289, PIECEMEAL_t = 290, QUIETLY_t = 291, RETURN_t = 292, RULE_t = 293, SWITCH_t = 294, TOGETHER_t = 295, UPDATED_t = 296, WHILE_t = 297, _LBRACE_t = 298, _BAR_t = 299, _BARBAR_t = 300, _RBRACE_t = 301, ARG = 302, STRING = 303 }
Functions
void	yydestruct (int yytype, YYSTYPE *yyvaluep)
int	yyparse ()
Variables
int	yychar
const short	yycheck []
const unsigned char	yydefact []
const short	yydefgoto []
YYSTYPE	yylval
int	yynerrs
const short	yypact []
const short	yypgoto []
const unsigned char	yyr1 []
const unsigned char	yyr2 []
const unsigned char	yystos []
const short	yytable []
const unsigned char	yytranslate []

The Machine Perception Toolbox

jamgram.c File Reference

Classes

Defines

Typedefs

Enumerations

Functions

Variables

Define Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation