configparser.cpp

最新osg包

    break;

  case 89:

    {
          cfg->setVisualByID( yyvsp[0].integer );
      ;}
    break;

  case 90:

    {
          cfg->addVisualAttribute( VisualChooser::BufferSize, yyvsp[0].integer );
      ;}
    break;

  case 91:

    {
          cfg->addVisualAttribute( VisualChooser::Level, yyvsp[0].integer );
      ;}
    break;

  case 92:

    {
          cfg->addVisualAttribute( VisualChooser::RGBA );
      ;}
    break;

  case 93:

    {
          cfg->addVisualAttribute( VisualChooser::DoubleBuffer );
      ;}
    break;

  case 94:

    {
          cfg->addVisualAttribute( VisualChooser::Stereo );
      ;}
    break;

  case 95:

    {
          cfg->addVisualAttribute( VisualChooser::AuxBuffers, yyvsp[0].integer );
      ;}
    break;

  case 96:

    {
          cfg->addVisualAttribute( VisualChooser::RedSize, yyvsp[0].integer );
      ;}
    break;

  case 97:

    {
          cfg->addVisualAttribute( VisualChooser::GreenSize, yyvsp[0].integer );
      ;}
    break;

  case 98:

    {
          cfg->addVisualAttribute( VisualChooser::BlueSize, yyvsp[0].integer );
      ;}
    break;

  case 99:

    {
          cfg->addVisualAttribute( VisualChooser::AlphaSize, yyvsp[0].integer );
      ;}
    break;

  case 100:

    {
          cfg->addVisualAttribute( VisualChooser::DepthSize, yyvsp[0].integer );
      ;}
    break;

  case 101:

    {
          cfg->addVisualAttribute( VisualChooser::StencilSize, yyvsp[0].integer );
      ;}
    break;

  case 102:

    {
          cfg->addVisualAttribute( VisualChooser::AccumRedSize, yyvsp[0].integer );
      ;}
    break;

  case 103:

    {
          cfg->addVisualAttribute( VisualChooser::AccumGreenSize, yyvsp[0].integer );
      ;}
    break;

  case 104:

    {
          cfg->addVisualAttribute( VisualChooser::AccumBlueSize, yyvsp[0].integer );
      ;}
    break;

  case 105:

    {
          cfg->addVisualAttribute( VisualChooser::AccumAlphaSize, yyvsp[0].integer );
      ;}
    break;

  case 106:

    {
          cfg->addVisualAttribute( VisualChooser::Samples, yyvsp[0].integer );
      ;}
    break;

  case 107:

    {
          cfg->addVisualAttribute( VisualChooser::SampleBuffers );
      ;}
    break;

  case 108:

    {
          cfg->addVisualExtendedAttribute( yyvsp[-1].integer, yyvsp[0].integer );
      ;}
    break;

  case 109:

    { cfg->beginInputArea(); ;}
    break;

  case 110:

    { cfg->endInputArea(); ;}
    break;

  case 113:

    {
            cfg->addInputAreaEntry( yyvsp[-1].string );
        ;}
    break;

  case 114:

    {
        yyval.real = atof(flexer->YYText());
    ;}
    break;

  case 115:

    {
        yyval.real = atof(flexer->YYText());
    ;}
    break;

  case 116:

    {
        yyval.real = atof(flexer->YYText());
    ;}
    break;

  case 117:

    {
        yyval.integer = atoi( flexer->YYText() );
    ;}
    break;

  case 118:

    {
        yyval.string = strdup( flexer->YYText() );
    ;}
    break;

  case 119:

    {
        yyval.string = strdup( flexer->YYText() );
    ;}
    break;

  case 120:

    {
        int n;
        sscanf( flexer->YYText(), "0x%x", &n );
        yyval.integer = n;
    ;}
    break;

  case 121:

    { yyval.boolean = true;;}
    break;

  case 122:

    { yyval.boolean = false; ;}
    break;


    }

/* Line 991 of yacc.c.  */


  yyvsp -= yylen;
  yyssp -= yylen;


  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;


  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTOKENS];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if YYERROR_VERBOSE
      yyn = yypact[yystate];

      if (YYPACT_NINF < yyn && yyn < YYLAST)
    {
      YYSIZE_T yysize = 0;
      int yytype = YYTRANSLATE (yychar);
      char *yymsg;
      int yyx, yycount;

      yycount = 0;
      /* Start YYX at -YYN if negative to avoid negative indexes in
         YYCHECK.  */
      for (yyx = yyn < 0 ? -yyn : 0;
           yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
          yysize += yystrlen (yytname[yyx]) + 15, yycount++;
      yysize += yystrlen ("syntax error, unexpected ") + 1;
      yysize += yystrlen (yytname[yytype]);
      yymsg = (char *) YYSTACK_ALLOC (yysize);
      if (yymsg != 0)
        {
          char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
          yyp = yystpcpy (yyp, yytname[yytype]);

          if (yycount < 5)
        {
          yycount = 0;
          for (yyx = yyn < 0 ? -yyn : 0;
               yyx < (int) (sizeof (yytname) / sizeof (char *));
               yyx++)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {
            const char *yyq = ! yycount ? ", expecting " : " or ";
            yyp = yystpcpy (yyp, yyq);
            yyp = yystpcpy (yyp, yytname[yyx]);
            yycount++;
              }
        }
          yyerror (yymsg);
          YYSTACK_FREE (yymsg);
        }
      else
        yyerror ("syntax error; also virtual memory exhausted");
    }
      else
#endif /* YYERROR_VERBOSE */
    yyerror ("syntax error");
    }



  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
     error, discard it.  */

      /* Return failure if at end of input.  */
      if (yychar == YYEOF)
        {
      /* Pop the error token.  */
          YYPOPSTACK;
      /* Pop the rest of the stack.  */
      while (yyss < yyssp)
        {
          YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
          yydestruct (yystos[*yyssp], yyvsp);
          YYPOPSTACK;
        }
      YYABORT;
        }

      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
      yydestruct (yytoken, &yylval);
      yychar = YYEMPTY;

    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab2;


/*----------------------------------------------------.
| yyerrlab1 -- error raised explicitly by an action.  |
`----------------------------------------------------*/
yyerrlab1:

  /* Suppress GCC warning that yyerrlab1 is unused when no action
     invokes YYERROR.  */
#if defined (__GNUC_MINOR__) && 2093 <= (__GNUC__ * 1000 + __GNUC_MINOR__) \
    && !defined __cplusplus
  __attribute__ ((__unused__))
#endif


  goto yyerrlab2;


/*---------------------------------------------------------------.
| yyerrlab2 -- pop states until the error token can be shifted.  |
`---------------------------------------------------------------*/
yyerrlab2:
  yyerrstatus = 3;    /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (yyn != YYPACT_NINF)
    {
      yyn += YYTERROR;
      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
        {
          yyn = yytable[yyn];
          if (0 < yyn)
        break;
        }
    }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
    YYABORT;

      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
      yydestruct (yystos[yystate], yyvsp);
      yyvsp--;
      yystate = *--yyssp;

      YY_STACK_PRINT (yyss, yyssp);
    }

  if (yyn == YYFINAL)
    YYACCEPT;

  YYDPRINTF ((stderr, "Shifting error token, "));

  *++yyvsp = yylval;


  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

#ifndef yyoverflow
/*----------------------------------------------.
| yyoverflowlab -- parser overflow comes here.  |
`----------------------------------------------*/
yyoverflowlab:
  yyerror ("parser stack overflow");
  yyresult = 2;
  /* Fall through.  */
#endif

yyreturn:
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
  return yyresult;
}





static void yyerror( const char *errmsg )
{
    fprintf( stder