torc::XdlParser Class Reference

A Bison parser. More...

#include <XdlParser.hpp>

Collaboration diagram for torc::XdlParser:

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
	XdlParser (class XdlImporter &xdl_yyarg)
	Build a parser object. More...
virtual	~XdlParser ()
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 XdlImporter &	xdl

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_ = -81
static const unsigned char	yydefact_ []
static const signed char	yypgoto_ []
static const short int	yydefgoto_ []
static const short int	yytable_ []
static const signed char	yytable_ninf_ = -4
static const short int	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_ = 124
static const int	yynnts_ = 68
static const int	yyempty_ = -2
static const int	yyfinal_ = 6
static const int	yyterror_ = 1
static const int	yyerrcode_ = 256
static const int	yyntokens_ = 41
static const unsigned int	yyuser_token_number_max_ = 291
static const token_number_type	yyundef_token_ = 2

Detailed Description

A Bison parser.

Definition at line 149 of file XdlParser.hpp.

Member Typedef Documentation

typedef int torc::XdlParser::debug_level_type

Type for debugging levels.

Definition at line 220 of file XdlParser.hpp.

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

private

location stack type.

Definition at line 262 of file XdlParser.hpp.

typedef location torc::XdlParser::location_type

Symbol locations.

Definition at line 159 of file XdlParser.hpp.

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

private

Semantic value stack type.

Definition at line 260 of file XdlParser.hpp.

typedef YYSTYPE torc::XdlParser::semantic_type

Symbol semantic values.

Definition at line 156 of file XdlParser.hpp.

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

private

State stack type.

Definition at line 258 of file XdlParser.hpp.

typedef int torc::XdlParser::state_type

private

State numbers.

Definition at line 256 of file XdlParser.hpp.

typedef unsigned char torc::XdlParser::token_number_type

private

Internal symbol numbers.

Definition at line 272 of file XdlParser.hpp.

typedef token::yytokentype torc::XdlParser::token_type

Token type.

Definition at line 204 of file XdlParser.hpp.

Constructor & Destructor Documentation

torc::XdlParser::XdlParser

(

class XdlImporter &

xdl_yyarg

)

Build a parser object.

Definition at line 147 of file XdlParser.cpp.

    : yydebug_ (false),
      yycdebug_ (&std::cerr),
      xdl (xdl_yyarg)
  {
  }

torc::XdlParser::~XdlParser ( )

virtual

Definition at line 154 of file XdlParser.cpp.

  {
  }

Member Function Documentation

XdlParser::debug_level_type torc::XdlParser::debug_level

(

)

const

The current debugging level.

Definition at line 229 of file XdlParser.cpp.

  {
    return yydebug_;
  }

std::ostream & torc::XdlParser::debug_stream

(

)

const

The current debugging stream.

Definition at line 216 of file XdlParser.cpp.

  {
    return *yycdebug_;
  }

void torc::XdlParser::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 1525 of file XdlParser.cpp.

                                                                             {
    xdl.error(l, m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int torc::XdlParser::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 XdlParser.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 93 "/Volumes/project/dev/torc/trunk/src/torc/physical/xdl/parser.yy"
{
    // initialize the initial location object
    yylloc.begin.filename = yylloc.end.filename = &xdl.mStreamName;
}
  /* Line 555 of yacc.c.  */
#line 282 "XdlParser.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 3:
#line 177 "parser.yy"
    { 
                            std::clog << "INFO: Parsed " << xdl.mInstanceCount << " instances, " 
                                << xdl.mNetCount << " nets, " << xdl.mConfigCount << " settings" 
                                << std::endl;
                         }
    break;

  case 9:
#line 192 "parser.yy"
    { /*std::clog << "ERROR at " << yylval << std::endl;*/ }
    break;

  case 11:
#line 201 "parser.yy"
    { xdl.mConfigMap.clearConfig(); }
    break;

  case 12:
#line 202 "parser.yy"
    {
                            if(true) std::clog << "INFO: design \"" << xdl.mDesignName << "\" " 
                                << xdl.mDesignDevice << xdl.mDesignPackage << xdl.mDesignSpeedGrade 
                                << std::endl;
                            // create the design
                            xdl.mDesignPtr = Factory::newDesignPtr(xdl.mDesignName, 
                                xdl.mDesignDevice, xdl.mDesignPackage, xdl.mDesignSpeedGrade, 
                                xdl.mDesignXdlVersion);
                            // add the design configs
                            xdl.mDesignPtr->addConfigs(xdl.mConfigMap);
                            // the design is the de facto circuit for instances and nets encountered
                            xdl.mCircuitPtr = xdl.mDesignPtr;
                            // construct and initialize the device database if applicable
                            xdl.initializeDatabase();
                        }
    break;

  case 13:
#line 220 "parser.yy"
    { 
                            xdl.mDesignName = xdl.lexer->last_string; 
                            xdl.lexer->last_string.clear(); 
                        }
    break;

  case 16:
#line 232 "parser.yy"
    {
                            torc::common::DeviceDesignator designator((yysemantic_stack_[(2) - (1)]));
                            xdl.mDesignDevice = designator.getDeviceName();
                            xdl.mDesignPackage = designator.getDevicePackage();
                            xdl.mDesignSpeedGrade = (yysemantic_stack_[(2) - (2)]);
                        }
    break;

  case 17:
#line 240 "parser.yy"
    { xdl.mDesignDevice = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 18:
#line 243 "parser.yy"
    { xdl.mDesignPackage = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 19:
#line 246 "parser.yy"
    { xdl.mDesignSpeedGrade = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 21:
#line 251 "parser.yy"
    { xdl.mDesignXdlVersion = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 28:
#line 284 "parser.yy"
    { xdl.mConfigMap.clearConfig(); xdl.mPortTempVector.clear(); }
    break;

  case 29:
#line 285 "parser.yy"
    { xdl.mModuleName = xdl.lexer->last_string; }
    break;

  case 30:
#line 286 "parser.yy"
    { xdl.mModuleAnchor = xdl.lexer->last_string; }
    break;

  case 31:
#line 287 "parser.yy"
    {
                            xdl.mModuleCount++;
                            if(false) std::clog << "INFO: module \"" << xdl.mModuleName 
                                << "\" @ \"" << xdl.mModuleAnchor << std::endl;
                            // create the module
                            xdl.mModulePtr = Factory::newModulePtr(xdl.mModuleName, 
                                xdl.mModuleAnchor);
                            // add the instance to the design
                            xdl.mDesignPtr->addModule(xdl.mModulePtr);
                            xdl.mModulePtr->setParentWeakPtr(xdl.mDesignPtr);
                            // add the module configs
                            xdl.mModulePtr->addConfigs(xdl.mConfigMap);
                            // set this module as the current circuit
                            xdl.mCircuitPtr = xdl.mModulePtr;
                        }
    break;

  case 32:
#line 305 "parser.yy"
    {
                            if(false) std::clog << "INFO: endmodule" << std::endl;
                            // iterate through the ports and instantiate them
                            PortTempVector::const_iterator p = xdl.mPortTempVector.begin();
                            PortTempVector::const_iterator e = xdl.mPortTempVector.end();
                            while(p < e) {
                                // get the port fields
                                const string& name = p->getName();
                                const string& instance = p->getInstance();
                                const string& pin = p->getPin();
                                // try to look up the instance in this module
                                // we should normally be more careful with lock(), but who else is 
                                // going to discard our pointer targets if the parser hasn't even 
                                // exposed the design to the world yet?
                                Circuit::InstanceSharedPtrIterator instanceIterator 
                                    = xdl.mCircuitPtr.lock()->findInstance(instance);
                                Circuit::InstanceSharedPtrIterator end = 
                                    xdl.mCircuitPtr.lock()->instancesEnd();
                                // catch references to undeclared instances
                                if(instanceIterator == end) {
                                    std::stringstream ss;
                                    ss << "Error: unknown instance \"" << xdl.mInstanceName 
                                        << "\" for port \"" << xdl.mPortName << "\" in module \"" 
                                        << xdl.mModuleName << "\".";
                                    xdl.error(ss.str()); //YYERROR;
                                    xdl.failure();
                                } else {
                                    if(false) std::clog << "INFO: port \"" << name << "\" " 
                                        << instance << "." << pin << std::endl;
                                    PortSharedPtr portPtr = Factory::newPortPtr(name, 
                                        *instanceIterator, pin);
                                    xdl.mModulePtr->addPort(portPtr);
                                }
                                // proceed to the next port
                                p++;
                            }
                            // the design is the de facto circuit for instances and nets 
                            // encountered outside of this module
                            xdl.mCircuitPtr = xdl.mDesignPtr;
                        }
    break;

  case 33:
#line 351 "parser.yy"
    { xdl.mPortName = xdl.lexer->last_string; }
    break;

  case 34:
#line 352 "parser.yy"
    { xdl.mPortInstance = xdl.lexer->last_string; }
    break;

  case 35:
#line 353 "parser.yy"
    { xdl.mPortPin = xdl.lexer->last_string; }
    break;

  case 36:
#line 353 "parser.yy"
    {
                            xdl.mPortTempVector.push_back(PortTemp(xdl.mPortName, xdl.mPortInstance, 
                                xdl.mPortPin));
                        }
    break;

  case 37:
#line 367 "parser.yy"
    { xdl.mConfigMap.clearConfig(); xdl.mInstanceReferencePtr.reset(); }
    break;

  case 38:
#line 368 "parser.yy"
    { xdl.mInstanceName = xdl.lexer->last_string; }
    break;

  case 39:
#line 369 "parser.yy"
    { xdl.mInstanceType = xdl.lexer->last_string; }
    break;

  case 40:
#line 372 "parser.yy"
    {
                            xdl.mInstanceCount++;
                            if(false) std::clog << "INFO: inst " << xdl.mInstanceType << " \"" 
                                << xdl.mInstanceName << "\"" << " @ " << xdl.mInstanceSite << " (" 
                                << xdl.mInstanceTile << ")" << std::endl;
                            // create the instance
                            xdl.mInstancePtr = Factory::newInstancePtr(xdl.mInstanceName, 
                                xdl.mInstanceType, xdl.mInstanceTile, xdl.mInstanceSite, 
                                xdl.mInstanceBonding, xdl.mInstanceReferencePtr);
                            // add the instance to the current circuit
                            xdl.mCircuitPtr.lock()->addInstance(xdl.mInstancePtr);
                            xdl.mInstancePtr->setParentWeakPtr(xdl.mCircuitPtr);
                            // add the instance configs
                            xdl.mInstancePtr->addConfigs(xdl.mConfigMap);
                        }
    break;

  case 41:
#line 390 "parser.yy"
    { 
                            xdl.mInstanceSite.clear(); xdl.mInstanceTile.clear(); 
                            xdl.mInstanceBonding = eInstanceBondingUnknown; 
                        }
    break;

  case 42:
#line 394 "parser.yy"
    { 
                            xdl.mInstanceTile = (yysemantic_stack_[(4) - (2)]); xdl.mInstanceSite = (yysemantic_stack_[(4) - (3)]); 
                            if(false) std::clog << "INFO:     " << xdl.mInstanceTile << " " << 
                                xdl.mInstanceSite << " " << xdl.mInstanceBonding << std::endl;
                        }
    break;

  case 43:
#line 402 "parser.yy"
    { xdl.mInstanceBonding = eInstanceBondingUnknown; }
    break;

  case 44:
#line 403 "parser.yy"
    { xdl.mInstanceBonding = eInstanceBondingBonded; }
    break;

  case 45:
#line 404 "parser.yy"
    { xdl.mInstanceBonding = eInstanceBondingUnbonded; }
    break;

  case 50:
#line 415 "parser.yy"
    { xdl.mReferenceModulePtr.reset(); xdl.mReferenceInstancePtr.reset(); }
    break;

  case 51:
#line 416 "parser.yy"
    { xdl.mReferenceInstantiation 
                            = xdl.lexer->last_string; }
    break;

  case 52:
#line 418 "parser.yy"
    { 
                            xdl.mReferenceModule = xdl.lexer->last_string; 
                            // look up the module
                            Design::ModuleSharedPtrIterator moduleIterator
                                = xdl.mDesignPtr->findModule(xdl.mReferenceModule);
                            Design::ModuleSharedPtrIterator end = xdl.mDesignPtr->modulesEnd();
                            if(moduleIterator == end) {
                                std::stringstream ss;
                                ss << "Error: unknown module \"" << xdl.mReferenceModule 
                                    << "\" referenced by instance \"" << xdl.mInstanceName << "\".";
                                xdl.error(ss.str()); YYERROR;
                            }
                            xdl.mReferenceModulePtr = *moduleIterator;
                        }
    break;

  case 53:
#line 432 "parser.yy"
    { 
                            xdl.mReferenceInstance = xdl.lexer->last_string;
                            // look up the instance
                            Circuit::InstanceSharedPtrIterator instanceIterator
                                = xdl.mReferenceModulePtr->findInstance(xdl.mReferenceInstance);
                            Circuit::InstanceSharedPtrIterator end 
                                = xdl.mReferenceModulePtr->instancesEnd();
                            if(instanceIterator == end) {
                                std::stringstream ss;
                                ss << "Error: unknown instance \"" << xdl.mReferenceInstance 
                                    << "\" in module \"" << xdl.mReferenceModule 
                                    << "\" referenced by instance \"" << xdl.mInstanceName << "\".";
                                xdl.error(ss.str()); YYERROR;
                            }
                            xdl.mReferenceInstancePtr = *instanceIterator;
                            // create an instance reference
                            InstanceReferenceSharedPtr instanceReferencePtr 
                                = Factory::newInstanceReferencePtr(xdl.mReferenceInstantiation, 
                                xdl.mReferenceModulePtr, xdl.mReferenceInstancePtr);
                            xdl.mInstanceReferencePtr = instanceReferencePtr;
                        }
    break;

  case 54:
#line 470 "parser.yy"
    { xdl.mConfigMap.clearConfig(); }
    break;

  case 55:
#line 471 "parser.yy"
    { xdl.mNetName = xdl.lexer->last_string; }
    break;

  case 56:
#line 472 "parser.yy"
    {
                            xdl.mNetCount++;
                            // create the net
                            xdl.mNetPtr = Factory::newNetPtr(xdl.mNetName, xdl.mNetType);
                        }
    break;

  case 57:
#line 476 "parser.yy"
    {
                            // add the net to the current circuit
                            CircuitSharedPtr circuitPtr = xdl.mCircuitPtr.lock();
                            circuitPtr->addNet(xdl.mNetPtr);
                            // add the net configs
                            xdl.mNetPtr->addConfigs(xdl.mConfigMap);
                            if(false) std::clog << "INFO: net " << xdl.mNetName << std::endl;
                        }
    break;

  case 58:
#line 487 "parser.yy"
    { xdl.mNetType = eNetTypeNormal; }
    break;

  case 59:
#line 488 "parser.yy"
    { xdl.mNetType = eNetTypePower; }
    break;

  case 60:
#line 489 "parser.yy"
    { xdl.mNetType = eNetTypeGround; }
    break;

  case 70:
#line 513 "parser.yy"
    {
                            xdl.mInstanceName = xdl.lexer->last_string;
                            xdl.mPinName = yylval;
                            CircuitSharedPtr circuitPtr = xdl.mCircuitPtr.lock();
                            Circuit::InstanceSharedPtrIterator instanceIterator 
                                = circuitPtr->findInstance(xdl.mInstanceName);
                            Circuit::InstanceSharedPtrIterator end = circuitPtr->instancesEnd();
                            // catch references to undeclared instances
                            if(instanceIterator == end) {
                                std::stringstream ss;
                                ss << "Error: unknown instance \"" << xdl.mInstanceName 
                                    << "\" for pin \"" << xdl.mInstanceName << "." 
                                    << xdl.mPinName << "\".";
                                xdl.error(ss.str()); YYERROR;
                            }
                            // proceed with the instance pin creation
                            InstanceSharedPtr instancePtr = *instanceIterator;
                            InstancePinSharedPtr instancePinPtr 
                                = Factory::newInstancePinPtr(instancePtr, xdl.mPinName);
                            xdl.bind(instancePinPtr);
                            switch(xdl.mPinDirection) {
                            case ePinDirectionInpin: 
                                xdl.mNetPtr->addSink(instancePinPtr); 
                                break;
                            case ePinDirectionOutpin: 
                                xdl.mNetPtr->addSource(instancePinPtr); 
                                break;
                            default: 
                                break;
                            }
                        }
    break;

  case 71:
#line 547 "parser.yy"
    { xdl.mPinDirection = ePinDirectionInpin; }
    break;

  case 72:
#line 548 "parser.yy"
    { xdl.mPinDirection = ePinDirectionOutpin; }
    break;

  case 73:
#line 554 "parser.yy"
    { xdl.mPipTile = yylval; }
    break;

  case 74:
#line 555 "parser.yy"
    { xdl.mPipSource = yylval; }
    break;

  case 75:
#line 557 "parser.yy"
    { xdl.mPipSink = yylval; }
    break;

  case 76:
#line 562 "parser.yy"
    { xdl.mPipDirection = ePipBidirectionalUnbuffered; }
    break;

  case 77:
#line 564 "parser.yy"
    { xdl.mPipDirection = ePipBidirectionalUnidirectionallyBuffered; }
    break;

  case 78:
#line 566 "parser.yy"
    { xdl.mPipDirection = ePipBidirectionalBidirectionallyBuffered; }
    break;

  case 79:
#line 568 "parser.yy"
    { xdl.mPipDirection = ePipUnidirectionalBuffered; }
    break;

  case 80:
#line 572 "parser.yy"
    {
                            Pip pip = Factory::newPip(xdl.mPipTile, xdl.mPipSource, xdl.mPipSink, 
                                xdl.mPipDirection);
                            xdl.mNetPtr->addPip(pip);
                            xdl.bind(pip, XdlImporter::ePipTypeRegular);
                        }
    break;

  case 81:
#line 578 "parser.yy"
    { xdl.mRoutethroughConfigSetting = yylval; }
    break;

  case 82:
#line 579 "parser.yy"
    { xdl.mRoutethroughConfigName = yylval; }
    break;

  case 83:
#line 580 "parser.yy"
    { xdl.mRoutethroughConfigValue = yylval; }
    break;

  case 84:
#line 581 "parser.yy"
    { xdl.mRoutethroughInstance = xdl.lexer->last_string; }
    break;

  case 85:
#line 582 "parser.yy"
    { xdl.mRoutethroughSource = yylval; }
    break;

  case 86:
#line 583 "parser.yy"
    {
                            xdl.mRoutethroughSink = yylval;
                            // look up the routethrough instance
                            CircuitSharedPtr circuitPtr = xdl.mCircuitPtr.lock();
                            Circuit::InstanceSharedPtrConstIterator instanceIterator 
                                = circuitPtr->findInstance(xdl.mRoutethroughInstance);
                            Circuit::InstanceSharedPtrConstIterator end 
                                = circuitPtr->instancesEnd();
                            // catch references to undeclared instances
                            if(instanceIterator == end) {
                                PipVector::const_iterator pipIter = --(xdl.mNetPtr->pipsEnd());
                                std::stringstream ss;
                                ss << "Error: unknown routhethrough instance \"" 
                                    << xdl.mRoutethroughInstance << "\" for pip \"" << *pipIter 
                                    << "\".";
                                xdl.error(ss.str()); YYERROR;
                            }
                            // proceed with the routethrough creation
                            const InstanceWeakPtr instancePtr = *instanceIterator;
                            // create a routethrough
                            RoutethroughSharedPtr routethroughPtr 
                                = Factory::newRoutethroughPtr(xdl.mRoutethroughConfigSetting, 
                                xdl.mRoutethroughConfigName, xdl.mRoutethroughConfigValue, 
                                instancePtr, xdl.mRoutethroughSource, xdl.mRoutethroughSink);
                            Pip pip = Factory::newPip(xdl.mPipTile, xdl.mPipSource, xdl.mPipSink, 
                                xdl.mPipDirection, routethroughPtr);
                            xdl.mNetPtr->addPip(pip);
                            xdl.bind(pip, XdlImporter::ePipTypeRoutethrough);
                        }
    break;

  case 89:
#line 622 "parser.yy"
    { xdl.mConfigMap.clearConfig(); }
    break;

  case 93:
#line 631 "parser.yy"
    {
                            if(xdl.mConfigValue.compare("#OFF")) {
                                xdl.mConfigMap.setConfig(xdl.mConfigSetting, xdl.mConfigName, 
                                    xdl.mConfigValue);
                                if(false) std::clog << "INFO:     " << xdl.mConfigSetting << ":" 
                                    << xdl.mConfigName << ":" << xdl.mConfigValue << std::endl;
                                xdl.mConfigCount++;
                            }
                        }
    break;

  case 94:
#line 643 "parser.yy"
    { xdl.mConfigSetting = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 95:
#line 647 "parser.yy"
    { xdl.mConfigName.clear(); }
    break;

  case 96:
#line 648 "parser.yy"
    { xdl.mConfigName = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 97:
#line 652 "parser.yy"
    { xdl.mConfigValue.clear(); }
    break;

  case 98:
#line 653 "parser.yy"
    { xdl.mConfigValue = (yysemantic_stack_[(1) - (1)]); }
    break;

  case 99:
#line 659 "parser.yy"
    { 
                            if(false) std::clog << "STRING: \"" << xdl.lexer->last_string << "\"" 
                            << std::endl; 
                        }
    break;


    /* Line 675 of lalr1.cc.  */
#line 941 "XdlParser.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::XdlParser::set_debug_level

(

debug_level_type

l

)

Set the current debugging level.

Definition at line 235 of file XdlParser.cpp.

  {
    yydebug_ = l;
  }

Here is the caller graph for this function:

void torc::XdlParser::set_debug_stream

(

std::ostream &

o

)

Set the current debugging stream.

Definition at line 222 of file XdlParser.cpp.

  {
    yycdebug_ = &o;
  }

void torc::XdlParser::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 XdlParser.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::XdlParser::yypop_ ( unsigned int  n = 1 )

inlineprivate

Pop n symbols the three stacks.

Definition at line 208 of file XdlParser.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::XdlParser::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 1097 of file XdlParser.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::XdlParser::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:

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

private

Convert a scanner token number t to a symbol number.

Definition at line 1459 of file XdlParser.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,    40,     2,     2,     2,     2,     2,
       2,     2,     2,     2,    38,     2,     2,     2,     2,     2,
       2,     2,     2,     2,     2,     2,     2,     2,    39,    37,
       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,    13,    14,
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
      35,    36
    };
    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 XdlImporter& torc::XdlParser::xdl

private

Definition at line 366 of file XdlParser.hpp.

std::ostream* torc::XdlParser::yycdebug_

private

Definition at line 362 of file XdlParser.hpp.

const short int torc::XdlParser::yycheck_

staticprivate

Initial value:

=
  {
        27,    28,    29,    83,    21,     5,    22,    20,    15,    16,
      10,    10,     0,    93,    11,    12,    43,    44,    17,    18,
      19,    13,    14,    40,    40,    38,    53,    54,     0,     1,
       4,    40,    21,     5,    25,    25,     8,     9,    37,    26,
      67,    27,    37,    10,   124,     6,     7,     8,     9,    20,
      77,    28,    29,    30,    31,    38,    37,    37,    40,    38,
      38,    37,    25,    38,    23,    25,    39,    37,    25,    38,
      38,    37,    25,    38,    25,   102,    24,    39,    25,    25,
      25,    39,    25,    39,    25,   107,    38,   155,    30,   117,
      30,    -1,    -1,    -1,    -1,    -1,   123,    -1,    -1,    -1,
      -1,    -1,    -1,    -1,    -1,    69,    -1,    -1,    -1,   136,
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   146,
      -1,    -1,    -1,    -1,   151
  }

Definition at line 294 of file XdlParser.hpp.

int torc::XdlParser::yydebug_

private

Definition at line 361 of file XdlParser.hpp.

const unsigned char torc::XdlParser::yydefact_

staticprivate

Initial value:

=
  {
         0,    11,     0,     2,     4,     0,     1,     0,     0,     0,
      13,     9,    28,    37,    54,     5,     6,    23,     7,     8,
     100,     0,    17,    20,    14,     0,     0,     0,     0,     0,
       0,   101,    99,    19,    16,    21,    87,    18,     0,    10,
      29,    38,    55,     0,     0,    24,    22,    25,    26,    27,
       0,     0,    15,     0,     0,    58,     0,    33,    89,    88,
      12,    30,    39,    59,    60,     0,    32,     0,     0,    87,
       0,    56,    34,    91,     0,     0,    61,     0,     0,    31,
       0,    43,    46,     0,    35,    94,    90,    92,     0,     0,
      44,    45,    41,     0,     0,    71,    72,     0,    57,    62,
      68,    64,     0,    80,    69,     0,    95,    43,    50,    48,
      47,    40,    73,    67,    63,     0,    81,    80,    66,    36,
      96,     0,    42,     0,     0,     0,    70,     0,    65,    97,
      51,    49,    74,     0,    98,    93,     0,     0,    82,    52,
      76,    77,    78,    79,     0,     0,     0,    75,     0,    53,
      83,     0,    84,     0,    85,     0,     0,    86
  }

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

Definition at line 281 of file XdlParser.hpp.

const short int torc::XdlParser::yydefgoto_

staticprivate

Initial value:

=
  {
        -1,     2,     3,     7,    15,    26,     4,     5,     9,    23,
      24,    25,    38,    34,    36,    16,    30,    45,    17,    27,
      53,    69,    46,    47,    67,    77,   105,    18,    28,    54,
      70,    82,    92,    94,   109,   123,   136,   146,    19,    29,
      55,    76,    65,    83,    99,   100,   101,   102,   103,   125,
     137,   144,   118,   127,   145,   151,   153,   155,    51,    59,
      68,    78,    87,    88,   121,   135,    10,    21
  }

Definition at line 284 of file XdlParser.hpp.

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

staticprivate

Definition at line 352 of file XdlParser.hpp.

const int torc::XdlParser::yyeof_ = 0

staticprivate

Definition at line 348 of file XdlParser.hpp.

const int torc::XdlParser::yyerrcode_ = 256

staticprivate

Definition at line 355 of file XdlParser.hpp.

const int torc::XdlParser::yyfinal_ = 6

staticprivate

Definition at line 353 of file XdlParser.hpp.

const int torc::XdlParser::yylast_ = 124

staticprivate

Definition at line 350 of file XdlParser.hpp.

location_stack_type torc::XdlParser::yylocation_stack_

private

The location stack.

Definition at line 269 of file XdlParser.hpp.

const int torc::XdlParser::yynnts_ = 68

staticprivate

Definition at line 351 of file XdlParser.hpp.

const int torc::XdlParser::yyntokens_ = 41

staticprivate

Definition at line 356 of file XdlParser.hpp.

const signed char torc::XdlParser::yypact_

staticprivate

Initial value:

=
  {
        26,   -81,    12,   -81,   -81,    -9,   -81,    28,    11,     9,
     -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,
     -81,   -17,    13,    14,   -81,    10,     5,    -9,    -9,    -9,
      39,   -81,   -81,   -81,   -81,   -81,    17,   -81,    13,   -81,
     -81,   -81,   -81,    -9,    -9,   -81,   -81,   -81,   -81,   -81,
      33,    19,   -81,    -9,    -9,    -7,    20,   -81,   -81,   -81,
     -81,   -81,   -81,   -81,   -81,    21,   -81,    -9,    18,    17,
      22,   -81,   -81,   -81,    24,     3,   -81,    -9,   -16,   -81,
      37,     8,    25,     1,   -81,   -81,   -81,   -81,    27,    40,
     -81,   -81,   -81,     0,    30,   -81,   -81,    43,   -81,   -81,
      31,    32,    -9,   -13,   -81,    34,    41,     8,   -81,    35,
     -81,   -81,   -81,   -81,   -81,    47,   -81,    29,   -81,   -81,
     -81,    38,   -81,    -9,    33,    49,   -81,    42,   -81,    52,
     -81,   -81,   -81,    53,   -81,   -81,    -9,    23,   -81,   -81,
     -81,   -81,   -81,   -81,    54,    44,    -9,   -81,    55,   -81,
     -81,    -9,   -81,    57,   -81,    23,    59,   -81
  }

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

Definition at line 275 of file XdlParser.hpp.

const signed char torc::XdlParser::yypact_ninf_ = -81

staticprivate

Definition at line 276 of file XdlParser.hpp.

const signed char torc::XdlParser::yypgoto_

staticprivate

Initial value:

=
  {
       -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,
     -81,   -81,   -81,    48,   -81,   -81,   -81,   -81,   -81,   -81,
     -81,   -81,   -81,   -81,   -81,   -81,   -81,    58,   -81,   -81,
     -81,   -81,   -22,   -81,   -81,   -81,   -81,   -81,    60,   -81,
     -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,   -81,
     -81,   -68,   -28,   -81,   -81,   -81,   -81,   -81,    36,   -80,
     -81,   -81,   -81,   -81,   -81,   -81,   -27,   -81
  }

Definition at line 283 of file XdlParser.hpp.

const unsigned char torc::XdlParser::yyr1_

staticprivate

Initial value:

=
  {
         0,    41,    42,    43,    44,    44,    45,    45,    45,    46,
      45,    48,    47,    49,    50,    50,    51,    52,    53,    54,
      55,    55,    56,    57,    57,    58,    58,    58,    60,    61,
      62,    59,    63,    65,    66,    67,    64,    69,    70,    71,
      68,    72,    72,    73,    73,    73,    74,    74,    74,    74,
      76,    77,    78,    75,    80,    81,    82,    79,    83,    83,
      83,    84,    84,    85,    85,    85,    85,    85,    85,    86,
      87,    88,    88,    90,    91,    89,    92,    92,    92,    92,
      93,    94,    95,    96,    97,    98,    93,    99,    99,   101,
     100,   102,   102,   103,   104,   105,   105,   106,   106,   107,
     108,   108
  }

For a rule, its LHS.

Definition at line 300 of file XdlParser.hpp.

const unsigned char torc::XdlParser::yyr2_

staticprivate

Initial value:

=
  {
         0,     2,     1,     2,     0,     2,     1,     1,     1,     0,
       3,     0,     7,     1,     1,     3,     2,     1,     1,     1,
       0,     1,     3,     0,     2,     1,     1,     1,     0,     0,
       0,     8,     3,     0,     0,     0,     8,     0,     0,     0,
      10,     2,     4,     0,     1,     1,     0,     2,     2,     4,
       0,     0,     0,     7,     0,     0,     0,     9,     0,     1,
       1,     0,     2,     2,     1,     3,     2,     2,     1,     1,
       3,     1,     1,     0,     0,     7,     1,     1,     1,     1,
       0,     0,     0,     0,     0,     0,    14,     0,     2,     0,
       5,     0,     2,     5,     1,     0,     1,     0,     1,     3,
       1,     2
  }

For a rule, its RHS length.

Definition at line 302 of file XdlParser.hpp.

semantic_stack_type torc::XdlParser::yysemantic_stack_

private

The semantic value stack.

Definition at line 267 of file XdlParser.hpp.

state_stack_type torc::XdlParser::yystate_stack_

private

The state stack.

Definition at line 265 of file XdlParser.hpp.

const unsigned char torc::XdlParser::yystos_

staticprivate

Initial value:

=
  {
         0,     4,    42,    43,    47,    48,     0,    44,    40,    49,
     107,     1,     5,     8,     9,    45,    56,    59,    68,    79,
      21,   108,    25,    50,    51,    52,    46,    60,    69,    80,
      57,    21,    40,    26,    54,    27,    55,    25,    53,    37,
     107,   107,   107,     6,     7,    58,    63,    64,    68,    79,
      38,    99,    54,    61,    70,    81,   107,   107,    10,   100,
      37,   107,   107,    15,    16,    83,    37,    65,   101,    62,
      71,    38,   107,    40,    99,    38,    82,    66,   102,    37,
      11,    12,    72,    84,   107,    22,    40,   103,   104,    25,
      13,    14,    73,    38,    74,    17,    18,    19,    37,    85,
      86,    87,    88,    89,   100,    67,    39,    25,     5,    75,
     100,    37,    25,    38,    38,   107,    20,    38,    93,    37,
      23,   105,    73,    76,    38,    90,    25,    94,    93,    39,
     107,   100,    25,    39,    24,   106,    77,    91,    25,   107,
      28,    29,    30,    31,    92,    95,    78,    25,    39,   107,
      25,    96,   107,    97,    25,    98,    92,    25
  }

For a state, its accessing symbol.

Definition at line 297 of file XdlParser.hpp.

const short int torc::XdlParser::yytable_

staticprivate

Initial value:

=
  {
        40,    41,    42,   104,    31,   108,    85,   116,    63,    64,
      58,    58,     6,   110,    80,    81,    56,    57,    95,    96,
      97,    90,    91,    32,    86,   117,    61,    62,    -3,    11,
       1,     8,    20,    12,    22,    37,    13,    14,    98,    33,
      72,    35,    39,    58,   131,    43,    44,    13,    14,   116,
      84,   140,   141,   142,   143,    50,    60,    66,    73,    71,
      75,    79,    89,    93,   120,   107,   106,   111,   112,   113,
     114,   119,   126,   124,   132,   115,   134,   129,   138,   147,
     150,   133,   154,   148,   157,   122,    52,   156,    48,   128,
      49,     0,     0,     0,     0,     0,   130,     0,     0,     0,
       0,     0,     0,     0,     0,    74,     0,     0,     0,   139,
       0,     0,     0,     0,     0,     0,     0,     0,     0,   149,
       0,     0,     0,     0,   152
  }

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 291 of file XdlParser.hpp.

const signed char torc::XdlParser::yytable_ninf_ = -4

staticprivate

Definition at line 292 of file XdlParser.hpp.

const int torc::XdlParser::yyterror_ = 1

staticprivate

Definition at line 354 of file XdlParser.hpp.

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

staticprivate

For a symbol, its name in clear.

Definition at line 306 of file XdlParser.hpp.

const XdlParser::token_number_type torc::XdlParser::yyundef_token_ = 2

staticprivate

Definition at line 358 of file XdlParser.hpp.

const unsigned int torc::XdlParser::yyuser_token_number_max_ = 291

staticprivate

Definition at line 357 of file XdlParser.hpp.

---

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

• XdlParser.hpp
• XdlParser.cpp