torc::LutParser Class Reference

A Bison parser. More...

#include <LutParser.hpp>

Collaboration diagram for torc::LutParser:

Data Structures
struct	token
	Tokens. More...

Public Types
typedef YYSTYPE	semantic_type
	Symbol semantic values. More...
typedef location	location_type
	Symbol locations. More...
typedef token::yytokentype	token_type
	Token type. More...
typedef int	debug_level_type
	Type for debugging levels. More...

Public Member Functions
	LutParser (class Assembler &lut_yyarg)
	Build a parser object. More...
virtual	~LutParser ()
virtual int	parse ()
std::ostream &	debug_stream () const
	The current debugging stream. More...
void	set_debug_stream (std::ostream &)
	Set the current debugging stream. More...
debug_level_type	debug_level () const
	The current debugging level. More...
void	set_debug_level (debug_level_type l)
	Set the current debugging level. More...

Private Types
typedef int	state_type
	State numbers. More...
typedef stack< state_type >	state_stack_type
	State stack type. More...
typedef stack< semantic_type >	semantic_stack_type
	Semantic value stack type. More...
typedef stack< location_type >	location_stack_type
	location stack type. More...
typedef unsigned char	token_number_type
	Internal symbol numbers. More...

Private Member Functions
virtual void	error (const location_type &loc, const std::string &msg)
virtual std::string	yysyntax_error_ (int yystate, int tok)
virtual std::string	yytnamerr_ (const char *n)
	Convert the symbol name n to a form suitable for a diagnostic. More...
token_number_type	yytranslate_ (int t)
	Convert a scanner token number t to a symbol number. More...
void	yydestruct_ (const char *yymsg, int yytype, semantic_type *yyvaluep, location_type *yylocationp)
	Reclaim the memory associated to a symbol. More...
void	yypop_ (unsigned int n=1)
	Pop n symbols the three stacks. More...

Private Attributes
state_stack_type	yystate_stack_
	The state stack. More...
semantic_stack_type	yysemantic_stack_
	The semantic value stack. More...
location_stack_type	yylocation_stack_
	The location stack. More...
int	yydebug_
std::ostream *	yycdebug_
class Assembler &	lut

Static Private Attributes
static const signed char	yypact_ []
	For a state, the index in yytable_ of its portion. More...
static const signed char	yypact_ninf_ = -5
static const unsigned char	yydefact_ []
static const signed char	yypgoto_ []
static const signed char	yydefgoto_ []
static const unsigned char	yytable_ []
static const signed char	yytable_ninf_ = -1
static const signed char	yycheck_ []
static const unsigned char	yystos_ []
	For a state, its accessing symbol. More...
static const unsigned char	yyr1_ []
	For a rule, its LHS. More...
static const unsigned char	yyr2_ []
	For a rule, its RHS length. More...
static const char *const	yytname_ []
	For a symbol, its name in clear. More...
static const int	yyeof_ = 0
static const int	yylast_ = 22
static const int	yynnts_ = 7
static const int	yyempty_ = -2
static const int	yyfinal_ = 13
static const int	yyterror_ = 1
static const int	yyerrcode_ = 256
static const int	yyntokens_ = 13
static const unsigned int	yyuser_token_number_max_ = 267
static const token_number_type	yyundef_token_ = 2

Detailed Description

A Bison parser.

Definition at line 144 of file LutParser.hpp.

Member Typedef Documentation

typedef int torc::LutParser::debug_level_type

Type for debugging levels.

Definition at line 191 of file LutParser.hpp.

typedef stack<location_type> torc::LutParser::location_stack_type

private

location stack type.

Definition at line 233 of file LutParser.hpp.

typedef location torc::LutParser::location_type

Symbol locations.

Definition at line 154 of file LutParser.hpp.

typedef stack<semantic_type> torc::LutParser::semantic_stack_type

private

Semantic value stack type.

Definition at line 231 of file LutParser.hpp.

typedef YYSTYPE torc::LutParser::semantic_type

Symbol semantic values.

Definition at line 151 of file LutParser.hpp.

typedef stack<state_type> torc::LutParser::state_stack_type

private

State stack type.

Definition at line 229 of file LutParser.hpp.

typedef int torc::LutParser::state_type

private

State numbers.

Definition at line 227 of file LutParser.hpp.

typedef unsigned char torc::LutParser::token_number_type

private

Internal symbol numbers.

Definition at line 243 of file LutParser.hpp.

typedef token::yytokentype torc::LutParser::token_type

Token type.

Definition at line 175 of file LutParser.hpp.

Constructor & Destructor Documentation

torc::LutParser::LutParser

(

class Assembler &

lut_yyarg

)

Build a parser object.

Definition at line 147 of file LutParser.cpp.

    : yydebug_ (false),
      yycdebug_ (&std::cerr),
      lut (lut_yyarg)
  {
  }

torc::LutParser::~LutParser ( )

virtual

Definition at line 154 of file LutParser.cpp.

  {
  }

Member Function Documentation

LutParser::debug_level_type torc::LutParser::debug_level

(

)

const

The current debugging level.

Definition at line 229 of file LutParser.cpp.

  {
    return yydebug_;
  }

std::ostream & torc::LutParser::debug_stream

(

)

const

The current debugging stream.

Definition at line 216 of file LutParser.cpp.

  {
    return *yycdebug_;
  }

void torc::LutParser::error ( const location_type &  loc, const std::string &  msg  )

privatevirtual

Report a syntax error.

Parameters

loc	where the syntax error is found.
msg	a description of the syntax error.

Definition at line 862 of file LutParser.cpp.

                                                                             {
    lut.error(l, m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int torc::LutParser::parse ( )

virtual

Parse.

Returns

0 iff parsing succeeded.

Look-ahead and look-ahead in internal form.

Semantic value of the look-ahead.

Location of the look-ahead.

The locations where the error started and ended.

$$.

$.

Definition at line 242 of file LutParser.cpp.

  {
    /// Look-ahead and look-ahead in internal form.
    int yychar = yyempty_;
    int yytoken = 0;

    /* State.  */
    int yyn;
    int yylen = 0;
    int yystate = 0;

    /* Error handling.  */
    int yynerrs_ = 0;
    int yyerrstatus_ = 0;

    /// Semantic value of the look-ahead.
    semantic_type yylval;
    /// Location of the look-ahead.
    location_type yylloc;
    /// The locations where the error started and ended.
    location yyerror_range[2];

    /// $$.
    semantic_type yyval;
    /// @$.
    location_type yyloc;

    int yyresult;

    YYCDEBUG << "Starting parse" << std::endl;


    /* User initialization code.  */
    #line 88 "/Volumes/project/dev/torc/trunk/src/torc/bitstream/assembler/lut/parser.yy"
{
    // initialize the initial location object
    yylloc.begin.filename = yylloc.end.filename = &lut.mStreamName;
}
  /* Line 555 of yacc.c.  */
#line 282 "LutParser.cpp"
    /* Initialize the stacks.  The initial state will be pushed in
       yynewstate, since the latter expects the semantical and the
       location values to have been already stored, initialize these
       stacks with a primary value.  */
    yystate_stack_ = state_stack_type (0);
    yysemantic_stack_ = semantic_stack_type (0);
    yylocation_stack_ = location_stack_type (0);
    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yylloc);

    /* New state.  */
  yynewstate:
    yystate_stack_.push (yystate);
    YYCDEBUG << "Entering state " << yystate << std::endl;
    goto yybackup;

    /* Backup.  */
  yybackup:

    /* Try to take a decision without look-ahead.  */
    yyn = yypact_[yystate];
    if (yyn == yypact_ninf_)
      goto yydefault;

    /* Read a look-ahead token.  */
    if (yychar == yyempty_)
      {
    YYCDEBUG << "Reading a token: ";
    yychar = yylex (&yylval, &yylloc);
      }


    /* Convert token to internal form.  */
    if (yychar <= yyeof_)
      {
    yychar = yytoken = yyeof_;
    YYCDEBUG << "Now at end of input." << std::endl;
      }
    else
      {
    yytoken = yytranslate_ (yychar);
    YY_SYMBOL_PRINT ("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;

    /* Reduce or error.  */
    yyn = yytable_[yyn];
    if (yyn <= 0)
      {
    if (yyn == 0 || yyn == yytable_ninf_)
    goto yyerrlab;
    yyn = -yyn;
    goto yyreduce;
      }

    /* Accept?  */
    if (yyn == yyfinal_)
      goto yyacceptlab;

    /* Shift the look-ahead token.  */
    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

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

    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yylloc);

    /* 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:
    yylen = yyr2_[yyn];
    /* If YYLEN is nonzero, implement the default value of the action:
       `$$ = $1'.  Otherwise, use the top of the stack.

       Otherwise, the following line sets YYVAL to garbage.
       This behavior is undocumented and Bison
       users should not rely upon it.  */
    if (yylen)
      yyval = yysemantic_stack_[yylen - 1];
    else
      yyval = yysemantic_stack_[0];

    {
      slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
      YYLLOC_DEFAULT (yyloc, slice, yylen);
    }
    YY_REDUCE_PRINT (yyn);
    switch (yyn)
      {
      case 4:
#line 147 "parser.yy"
    { (yyval) = (yysemantic_stack_[(3) - (1)]) + " xor " + (yysemantic_stack_[(3) - (3)]); lut.binaryLutFrameOperation(Assembler::eOR); }
    break;

  case 6:
#line 153 "parser.yy"
    { (yyval) = (yysemantic_stack_[(3) - (1)]) + " xor " + (yysemantic_stack_[(3) - (3)]); lut.binaryLutFrameOperation(Assembler::eXOR); }
    break;

  case 8:
#line 159 "parser.yy"
    { (yyval) = (yysemantic_stack_[(3) - (1)]) + " and " + (yysemantic_stack_[(3) - (3)]); lut.binaryLutFrameOperation(Assembler::eAND); }
    break;

  case 10:
#line 164 "parser.yy"
    { (yyval) = "not " + (yysemantic_stack_[(2) - (2)]); lut.binaryLutFrameOperation(Assembler::eNOT); }
    break;

  case 11:
#line 167 "parser.yy"
    { (yyval) = (yysemantic_stack_[(3) - (2)]); }
    break;

  case 12:
#line 168 "parser.yy"
    { (yyval) = (yysemantic_stack_[(1) - (1)]); lut.pushLutFrame(yylval); }
    break;


    /* Line 675 of lalr1.cc.  */
#line 429 "LutParser.cpp"
    default: break;
      }
    YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);

    yypop_ (yylen);
    yylen = 0;
    YY_STACK_PRINT ();

    yysemantic_stack_.push (yyval);
    yylocation_stack_.push (yyloc);

    /* Shift the result of the reduction.  */
    yyn = yyr1_[yyn];
    yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
    if (0 <= yystate && yystate <= yylast_
    && yycheck_[yystate] == yystate_stack_[0])
      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_;
    error (yylloc, yysyntax_error_ (yystate, yytoken));
      }

    yyerror_range[0] = yylloc;
    if (yyerrstatus_ == 3)
      {
    /* If just tried and failed to reuse look-ahead token after an
     error, discard it.  */

    if (yychar <= yyeof_)
      {
      /* Return failure if at end of input.  */
      if (yychar == yyeof_)
        YYABORT;
      }
    else
      {
        yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
        yychar = yyempty_;
      }
      }

    /* Else will try to reuse look-ahead token after shifting the error
       token.  */
    goto yyerrlab1;


  /*---------------------------------------------------.
  | yyerrorlab -- error raised explicitly by YYERROR.  |
  `---------------------------------------------------*/
  yyerrorlab:

    /* Pacify compilers like GCC when the user code never invokes
       YYERROR and the label yyerrorlab therefore never appears in user
       code.  */
    if (false)
      goto yyerrorlab;

    yyerror_range[0] = yylocation_stack_[yylen - 1];
    /* Do not reclaim the symbols of the rule which action triggered
       this YYERROR.  */
    yypop_ (yylen);
    yylen = 0;
    yystate = yystate_stack_[0];
    goto yyerrlab1;

  /*-------------------------------------------------------------.
  | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  `-------------------------------------------------------------*/
  yyerrlab1:
    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 (yystate_stack_.height () == 1)
    YYABORT;

    yyerror_range[0] = yylocation_stack_[0];
    yydestruct_ ("Error: popping",
             yystos_[yystate],
             &yysemantic_stack_[0], &yylocation_stack_[0]);
    yypop_ ();
    yystate = yystate_stack_[0];
    YY_STACK_PRINT ();
      }

    if (yyn == yyfinal_)
      goto yyacceptlab;

    yyerror_range[1] = yylloc;
    // Using YYLLOC is tempting, but would change the location of
    // the look-ahead.  YYLOC is available though.
    YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
    yysemantic_stack_.push (yylval);
    yylocation_stack_.push (yyloc);

    /* Shift the error token.  */
    YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
           &yysemantic_stack_[0], &yylocation_stack_[0]);

    yystate = yyn;
    goto yynewstate;

    /* Accept.  */
  yyacceptlab:
    yyresult = 0;
    goto yyreturn;

    /* Abort.  */
  yyabortlab:
    yyresult = 1;
    goto yyreturn;

  yyreturn:
    if (yychar != yyeof_ && yychar != yyempty_)
      yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);

    /* Do not reclaim the symbols of the rule which action triggered
       this YYABORT or YYACCEPT.  */
    yypop_ (yylen);
    while (yystate_stack_.height () != 1)
      {
    yydestruct_ ("Cleanup: popping",
           yystos_[yystate_stack_[0]],
           &yysemantic_stack_[0],
           &yylocation_stack_[0]);
    yypop_ ();
      }

    return yyresult;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void torc::LutParser::set_debug_level

(

debug_level_type

l

)

Set the current debugging level.

Definition at line 235 of file LutParser.cpp.

  {
    yydebug_ = l;
  }

Here is the caller graph for this function:

void torc::LutParser::set_debug_stream

(

std::ostream &

o

)

Set the current debugging stream.

Definition at line 222 of file LutParser.cpp.

  {
    yycdebug_ = &o;
  }

void torc::LutParser::yydestruct_ ( const char *  yymsg, int  yytype, semantic_type *  yyvaluep, location_type *  yylocationp  )

inlineprivate

Reclaim the memory associated to a symbol.

Parameters

yymsg	Why this token is reclaimed.
yytype	The symbol type.
yyvaluep	Its semantic value.
yylocationp	Its location.

Definition at line 190 of file LutParser.cpp.

  {
    YYUSE (yylocationp);
    YYUSE (yymsg);
    YYUSE (yyvaluep);

    YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

    switch (yytype)
      {
  
    default:
      break;
      }
  }

Here is the caller graph for this function:

void torc::LutParser::yypop_ ( unsigned int  n = 1 )

inlineprivate

Pop n symbols the three stacks.

Definition at line 208 of file LutParser.cpp.

  {
    yystate_stack_.pop (n);
    yysemantic_stack_.pop (n);
    yylocation_stack_.pop (n);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string torc::LutParser::yysyntax_error_ ( int  yystate, int  tok  )

privatevirtual

Generate an error message.

Parameters

state	the state where the error occurred.
tok	the look-ahead token.

Definition at line 585 of file LutParser.cpp.

  {
    std::string res;
    YYUSE (yystate);
#if YYERROR_VERBOSE
    int yyn = yypact_[yystate];
    if (yypact_ninf_ < yyn && yyn <= yylast_)
      {
    /* Start YYX at -YYN if negative to avoid negative indexes in
       YYCHECK.  */
    int yyxbegin = yyn < 0 ? -yyn : 0;

    /* Stay within bounds of both yycheck and yytname.  */
    int yychecklim = yylast_ - yyn + 1;
    int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
    int count = 0;
    for (int x = yyxbegin; x < yyxend; ++x)
      if (yycheck_[x + yyn] == x && x != yyterror_)
        ++count;

    // FIXME: This method of building the message is not compatible
    // with internationalization.  It should work like yacc.c does it.
    // That is, first build a string that looks like this:
    // "syntax error, unexpected %s or %s or %s"
    // Then, invoke YY_ on this string.
    // Finally, use the string as a format to output
    // yytname_[tok], etc.
    // Until this gets fixed, this message appears in English only.
    res = "syntax error, unexpected ";
    res += yytnamerr_ (yytname_[tok]);
    if (count < 5)
      {
        count = 0;
        for (int x = yyxbegin; x < yyxend; ++x)
          if (yycheck_[x + yyn] == x && x != yyterror_)
        {
          res += (!count++) ? ", expecting " : " or ";
          res += yytnamerr_ (yytname_[x]);
        }
      }
      }
    else
#endif
      res = YY_("syntax error");
    return res;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual std::string torc::LutParser::yytnamerr_ ( const char *  n )

privatevirtual

Convert the symbol name n to a form suitable for a diagnostic.

Here is the caller graph for this function:

LutParser::token_number_type torc::LutParser::yytranslate_ ( int  t )

private

Convert a scanner token number t to a symbol number.

Definition at line 799 of file LutParser.cpp.

  {
    static
    const token_number_type
    translate_table[] =
    {
           0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
       5,     6,     7,     8,     9,    10,    11,    12
    };
    if ((unsigned int) t <= yyuser_token_number_max_)
      return translate_table[t];
    else
      return yyundef_token_;
  }

Here is the caller graph for this function:

Field Documentation

class Assembler& torc::LutParser::lut

private

Definition at line 337 of file LutParser.hpp.

std::ostream* torc::LutParser::yycdebug_

private

Definition at line 333 of file LutParser.hpp.

const signed char torc::LutParser::yycheck_

staticprivate

Initial value:

=
  {
         4,     5,     4,     5,     8,     0,     7,    11,     7,    11,
       6,    10,     9,     4,    14,     3,    -1,    15,    -1,    -1,
      -1,    -1,    16
  }

Definition at line 265 of file LutParser.hpp.

int torc::LutParser::yydebug_

private

Definition at line 332 of file LutParser.hpp.

const unsigned char torc::LutParser::yydefact_

staticprivate

Initial value:

=
  {
         0,    12,    13,     0,     0,     0,     2,     3,     5,     7,
       9,    10,     0,     1,     0,     0,     0,    11,     4,     6,
       8
  }

For a state, default rule to reduce. Unlessyytable_ specifies something else to do. Zero means the default is an error.

Definition at line 252 of file LutParser.hpp.

const signed char torc::LutParser::yydefgoto_

staticprivate

Initial value:

=
  {
        -1,     5,     6,     7,     8,     9,    10
  }

Definition at line 255 of file LutParser.hpp.

const int torc::LutParser::yyempty_ = -2

staticprivate

Definition at line 323 of file LutParser.hpp.

const int torc::LutParser::yyeof_ = 0

staticprivate

Definition at line 319 of file LutParser.hpp.

const int torc::LutParser::yyerrcode_ = 256

staticprivate

Definition at line 326 of file LutParser.hpp.

const int torc::LutParser::yyfinal_ = 13

staticprivate

Definition at line 324 of file LutParser.hpp.

const int torc::LutParser::yylast_ = 22

staticprivate

Definition at line 321 of file LutParser.hpp.

location_stack_type torc::LutParser::yylocation_stack_

private

The location stack.

Definition at line 240 of file LutParser.hpp.

const int torc::LutParser::yynnts_ = 7

staticprivate

Definition at line 322 of file LutParser.hpp.

const int torc::LutParser::yyntokens_ = 13

staticprivate

Definition at line 327 of file LutParser.hpp.

const signed char torc::LutParser::yypact_

staticprivate

Initial value:

=
  {
        -4,    -5,    -5,    -2,    -4,     5,    -1,     3,     4,    -5,
      -5,    -5,     1,    -5,    -4,    -4,    -4,    -5,     3,     4,
      -5
  }

For a state, the index in yytable_ of its portion.

Definition at line 246 of file LutParser.hpp.

const signed char torc::LutParser::yypact_ninf_ = -5

staticprivate

Definition at line 247 of file LutParser.hpp.

const signed char torc::LutParser::yypgoto_

staticprivate

Initial value:

=
  {
        -5,    -5,     9,     0,     2,     6,    12
  }

Definition at line 254 of file LutParser.hpp.

const unsigned char torc::LutParser::yyr1_

staticprivate

Initial value:

=
  {
         0,    13,    14,    15,    15,    16,    16,    17,    17,    18,
      18,    19,    19,    19
  }

For a rule, its LHS.

Definition at line 271 of file LutParser.hpp.

const unsigned char torc::LutParser::yyr2_

staticprivate

Initial value:

=
  {
         0,     2,     1,     1,     3,     1,     3,     1,     3,     1,
       2,     3,     1,     1
  }

For a rule, its RHS length.

Definition at line 273 of file LutParser.hpp.

semantic_stack_type torc::LutParser::yysemantic_stack_

private

The semantic value stack.

Definition at line 238 of file LutParser.hpp.

state_stack_type torc::LutParser::yystate_stack_

private

The state stack.

Definition at line 236 of file LutParser.hpp.

const unsigned char torc::LutParser::yystos_

staticprivate

Initial value:

=
  {
         0,     4,     5,     8,    11,    14,    15,    16,    17,    18,
      19,    19,    15,     0,     7,     9,     6,    10,    16,    17,
      18
  }

For a state, its accessing symbol.

Definition at line 268 of file LutParser.hpp.

const unsigned char torc::LutParser::yytable_

staticprivate

Initial value:

=
  {
         1,     2,     1,     2,     3,    13,    14,     4,    14,     4,
      16,    17,    15,    12,    18,    11,     0,    19,     0,     0,
       0,     0,    20
  }

What to do in a state. yytable_[yypact_[s]]: what to do in state s.

• if positive, shift that token.
• if negative, reduce the rule which number is the opposite.
• if zero, do what YYDEFACT says.

Definition at line 262 of file LutParser.hpp.

const signed char torc::LutParser::yytable_ninf_ = -1

staticprivate

Definition at line 263 of file LutParser.hpp.

const int torc::LutParser::yyterror_ = 1

staticprivate

Definition at line 325 of file LutParser.hpp.

const char* const torc::LutParser::yytname_[]

staticprivate

For a symbol, its name in clear.

Definition at line 277 of file LutParser.hpp.

const LutParser::token_number_type torc::LutParser::yyundef_token_ = 2

staticprivate

Definition at line 329 of file LutParser.hpp.

const unsigned int torc::LutParser::yyuser_token_number_max_ = 267

staticprivate

Definition at line 328 of file LutParser.hpp.

---

The documentation for this class was generated from the following files:

• LutParser.hpp
• LutParser.cpp