Source for the XdlScanner class. More...

#include <iostream>
#include <errno.h>
#include <cstdlib>
#include <cstring>
#include <FlexLexer.h>
#include <string>
#include "torc/physical/xdl/XdlScanner.hpp"

Include dependency graph for XdlScanner.cpp:

Go to the source code of this file.

Data Structures
struct	yy_buffer_state
	Bison parser internals. More...

struct	yy_trans_info
	Bison parser internals. More...

Namespaces
	torc
	Implementation of class to encapsulate micro-bitstream library generation code.

	torc::physical
	Namespace for the Torc physical netlist, including the XDL importer, exporter, placer, router, unpacker, and packer.

Macros
#define	YY_INT_ALIGNED short int

#define	FLEX_SCANNER

#define	YY_FLEX_MAJOR_VERSION 2

#define	YY_FLEX_MINOR_VERSION 5

#define	YY_FLEX_SUBMINOR_VERSION 35

#define	FLEX_BETA

#define	yyFlexLexer XdlFlexLexer

#define	FLEXINT_H

#define	INT8_MIN (-128)

#define	INT16_MIN (-32767-1)

#define	INT32_MIN (-2147483647-1)

#define	INT8_MAX (127)

#define	INT16_MAX (32767)

#define	INT32_MAX (2147483647)

#define	UINT8_MAX (255U)

#define	UINT16_MAX (65535U)

#define	UINT32_MAX (4294967295U)

#define	yyconst

#define	YY_NULL 0

#define	YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)

#define	BEGIN (yy_start) = 1 + 2 *

#define	YY_START (((yy_start) - 1) / 2)

#define	YYSTATE YY_START

#define	YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

#define	YY_NEW_FILE yyrestart( yyin )

#define	YY_END_OF_BUFFER_CHAR 0

#define	YY_BUF_SIZE 16384

#define	YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

#define	YY_TYPEDEF_YY_BUFFER_STATE

#define	EOB_ACT_CONTINUE_SCAN 0

#define	EOB_ACT_END_OF_FILE 1

#define	EOB_ACT_LAST_MATCH 2

#define	YY_LESS_LINENO(n)

#define	yyless(n)

#define	unput(c) yyunput( c, (yytext_ptr) )

#define	YY_TYPEDEF_YY_SIZE_T

#define	YY_STRUCT_YY_BUFFER_STATE

#define	YY_BUFFER_NEW 0

#define	YY_BUFFER_NORMAL 1

#define	YY_BUFFER_EOF_PENDING 2

#define	YY_CURRENT_BUFFER

#define	YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

#define	yy_new_buffer yy_create_buffer

#define	yy_set_interactive(is_interactive)

#define	yy_set_bol(at_bol)

#define	YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

#define	yytext_ptr yytext

#define	YY_DO_BEFORE_ACTION

#define	YY_NUM_RULES 45

#define	YY_END_OF_BUFFER 46

#define	REJECT

#define	yymore() yymore_used_but_not_detected

#define	YY_MORE_ADJ 0

#define	YY_RESTORE_YY_MORE_OFFSET

#define	yyterminate() return token::END

#define	YY_NO_UNISTD_H
	Disable the inclusion of unistd.h, which is not available under Visual C++ on Win32. More...

#define	DEBUG(a)

#define	DEBUG1(a) printf a

#define	YY_USER_ACTION yylloc->columns(yyleng);
	Enable C++ generation for the scanner class. More...

#define	INITIAL 0
	Special lexing state for config strings. More...

#define	CONFIGSTRING 1
	Bison lexer internals. More...

#define	CONFIGSTRING2 2
	Bison lexer internals. More...

#define	DOUBLEQUOTE 3
	Bison lexer internals. More...

#define	YY_EXTRA_TYPE void *

#define	YY_READ_BUF_SIZE 8192

#define	ECHO LexerOutput( yytext, yyleng )

#define	YY_INPUT(buf, result, max_size)

#define	YY_START_STACK_INCR 25

#define	YY_FATAL_ERROR(msg) LexerError( msg )

#define	YY_DECL_IS_OURS 1

#define	YY_DECL int yyFlexLexer::yylex()

#define	YY_BREAK break;

#define	YY_RULE_SETUP YY_USER_ACTION

#define	YY_EXIT_FAILURE 2

#define	yyless(n)

#define	YYTABLES_NAME "yytables"

Typedefs
typedef signed char	flex_int8_t

typedef short int	flex_int16_t

typedef int	flex_int32_t

typedef unsigned char	flex_uint8_t

typedef unsigned short int	flex_uint16_t

typedef unsigned int	flex_uint32_t

typedef struct yy_buffer_state *	YY_BUFFER_STATE

typedef size_t	yy_size_t

typedef unsigned char	YY_CHAR

typedef torc::XdlParser::token	token
	Import the parser's token types into a local typedef. More...

typedef torc::XdlParser::token_type	token_type

Functions
void *	Xdlalloc (yy_size_t)
	Bison lexer internals. More...

void *	Xdlrealloc (void *, yy_size_t)
	Bison lexer internals. More...

void	Xdlfree (void *)
	Bison lexer internals. More...

yylloc	step ()
	Code belonging at the beginning of yylex(). More...

	if (!(yy_init))

	while (1)

int	isatty (int)

Variables
int	yyleng

static yyconst flex_int16_t	yy_acclist [232]

static yyconst flex_int16_t	yy_accept [170]

static yyconst flex_int32_t	yy_ec [256]

static yyconst flex_int32_t	yy_meta [44]

static yyconst flex_int16_t	yy_base [179]

static yyconst flex_int16_t	yy_def [179]

static yyconst flex_int16_t	yy_nxt [322]

static yyconst flex_int16_t	yy_chk [322]

YY_DECL register yy_state_type	yy_current_state

register char *	yy_cp

register char *	yy_bp

register int	yy_act

Detailed Description

Source for the XdlScanner class.

Definition in file XdlScanner.cpp.

Macro Definition Documentation

#define BEGIN (yy_start) = 1 + 2 *

Definition at line 136 of file XdlScanner.cpp.

#define CONFIGSTRING 1

Bison lexer internals.

Definition at line 637 of file XdlScanner.cpp.

#define CONFIGSTRING2 2

Bison lexer internals.

Definition at line 638 of file XdlScanner.cpp.

#define DEBUG ( a )

Definition at line 611 of file XdlScanner.cpp.

#define DEBUG1 ( a ) printf a

Definition at line 612 of file XdlScanner.cpp.

#define DOUBLEQUOTE 3

Bison lexer internals.

Definition at line 639 of file XdlScanner.cpp.

#define ECHO LexerOutput( yytext, yyleng )

Definition at line 672 of file XdlScanner.cpp.

#define EOB_ACT_CONTINUE_SCAN 0

Definition at line 169 of file XdlScanner.cpp.

#define EOB_ACT_END_OF_FILE 1

Definition at line 170 of file XdlScanner.cpp.

#define EOB_ACT_LAST_MATCH 2

Definition at line 171 of file XdlScanner.cpp.

#define FLEX_BETA

Definition at line 14 of file XdlScanner.cpp.

#define FLEX_SCANNER

Definition at line 9 of file XdlScanner.cpp.

#define FLEXINT_H

Definition at line 34 of file XdlScanner.cpp.

#define INITIAL 0

Special lexing state for config strings.

Special second lexing state for config strings. Special lexing state for double-quoted strings.

Definition at line 636 of file XdlScanner.cpp.

#define INT16_MAX (32767)

Definition at line 77 of file XdlScanner.cpp.

#define INT16_MIN (-32767-1)

Definition at line 68 of file XdlScanner.cpp.

#define INT32_MAX (2147483647)

Definition at line 80 of file XdlScanner.cpp.

#define INT32_MIN (-2147483647-1)

Definition at line 71 of file XdlScanner.cpp.

#define INT8_MAX (127)

Definition at line 74 of file XdlScanner.cpp.

#define INT8_MIN (-128)

Definition at line 65 of file XdlScanner.cpp.

#define REJECT

Value:

{ \
*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ \
yy_cp = (yy_full_match); /* restore poss. backed-over text */ \
++(yy_lp); \
goto find_rule; \
}

Definition at line 551 of file XdlScanner.cpp.

#define UINT16_MAX (65535U)

Definition at line 86 of file XdlScanner.cpp.

#define UINT32_MAX (4294967295U)

Definition at line 89 of file XdlScanner.cpp.

#define UINT8_MAX (255U)

Definition at line 83 of file XdlScanner.cpp.

#define unput ( c ) yyunput( c, (yytext_ptr) )

Definition at line 189 of file XdlScanner.cpp.

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 303 of file XdlScanner.cpp.

#define YY_BREAK break;

Definition at line 723 of file XdlScanner.cpp.

#define YY_BUF_SIZE 16384

Definition at line 155 of file XdlScanner.cpp.

#define YY_BUFFER_EOF_PENDING 2

Definition at line 257 of file XdlScanner.cpp.

#define YY_BUFFER_NEW 0

Definition at line 245 of file XdlScanner.cpp.

#define YY_BUFFER_NORMAL 1

Definition at line 246 of file XdlScanner.cpp.

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 268 of file XdlScanner.cpp.

#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 275 of file XdlScanner.cpp.

#define YY_DECL int yyFlexLexer::yylex()

Definition at line 711 of file XdlScanner.cpp.

#define YY_DECL_IS_OURS 1

Definition at line 710 of file XdlScanner.cpp.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
	yyleng = (size_t) (yy_cp - yy_bp); \
    (yy_hold_char) = *yy_cp; \
    *yy_cp = '\0'; \
    (yy_c_buf_p) = yy_cp;

Definition at line 316 of file XdlScanner.cpp.

#define YY_END_OF_BUFFER 46

Definition at line 324 of file XdlScanner.cpp.

#define YY_END_OF_BUFFER_CHAR 0

Definition at line 151 of file XdlScanner.cpp.

#define YY_EXIT_FAILURE 2

Definition at line 1935 of file XdlScanner.cpp.

#define YY_EXTRA_TYPE void *

Definition at line 650 of file XdlScanner.cpp.

#define YY_FATAL_ERROR ( msg ) LexerError( msg )

Definition at line 701 of file XdlScanner.cpp.

#define YY_FLEX_MAJOR_VERSION 2

Definition at line 10 of file XdlScanner.cpp.

#define YY_FLEX_MINOR_VERSION 5

Definition at line 11 of file XdlScanner.cpp.

#define YY_FLEX_SUBMINOR_VERSION 35

Definition at line 12 of file XdlScanner.cpp.

#define YY_INPUT	(	buf,
		result,
		max_size
	)

Value:

\
	if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );

Definition at line 679 of file XdlScanner.cpp.

#define YY_INT_ALIGNED short int

Definition at line 5 of file XdlScanner.cpp.

#define YY_LESS_LINENO ( n )

Definition at line 173 of file XdlScanner.cpp.

#define YY_MORE_ADJ 0

Definition at line 560 of file XdlScanner.cpp.

#define yy_new_buffer yy_create_buffer

Definition at line 281 of file XdlScanner.cpp.

#define YY_NEW_FILE yyrestart( yyin )

Definition at line 149 of file XdlScanner.cpp.

#define YY_NO_UNISTD_H

Disable the inclusion of unistd.h, which is not available under Visual C++ on Win32.

The C++ scanner uses STL streams instead.

Definition at line 608 of file XdlScanner.cpp.

#define YY_NULL 0

Definition at line 123 of file XdlScanner.cpp.

#define YY_NUM_RULES 45

Definition at line 323 of file XdlScanner.cpp.

#define YY_READ_BUF_SIZE 8192

Definition at line 667 of file XdlScanner.cpp.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 561 of file XdlScanner.cpp.

#define YY_RULE_SETUP YY_USER_ACTION

Definition at line 726 of file XdlScanner.cpp.

#define YY_SC_TO_UI ( c ) ((unsigned int) (unsigned char) c)

Definition at line 130 of file XdlScanner.cpp.

#define yy_set_bol ( at_bol )

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){\
        yyensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    }

Definition at line 293 of file XdlScanner.cpp.

#define yy_set_interactive ( is_interactive )

Value:

{ \
	if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer( yyin, YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

Definition at line 283 of file XdlScanner.cpp.

#define YY_START (((yy_start) - 1) / 2)

Definition at line 142 of file XdlScanner.cpp.

#define YY_START_STACK_INCR 25

Definition at line 696 of file XdlScanner.cpp.

#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 160 of file XdlScanner.cpp.

#define YY_STATE_EOF ( state ) (YY_END_OF_BUFFER + state + 1)

Definition at line 146 of file XdlScanner.cpp.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 197 of file XdlScanner.cpp.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 163 of file XdlScanner.cpp.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 192 of file XdlScanner.cpp.

#define YY_USER_ACTION yylloc->columns(yyleng);

Enable C++ generation for the scanner class.

Change the name of the scanner class to "XdlFlexLexer". The manual says batch is "somewhat more optimized". Enable debug output from the scanner. We anticipate no included XDL files. Enable the use of start condition stacks. Track location information. Each time yylex is invoked, begin is moved to end.

Definition at line 627 of file XdlScanner.cpp.

#define yyconst

Definition at line 119 of file XdlScanner.cpp.

#define yyFlexLexer XdlFlexLexer

Definition at line 23 of file XdlScanner.cpp.

#define yyless ( n )

Value:

do \
        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        *yy_cp = (yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
        (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
        } \
	while ( 0 )

Definition at line 1947 of file XdlScanner.cpp.

#define yyless ( n )

Value:

do \
        { \
        /* Undo effects of setting up yytext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        yytext[yyleng] = (yy_hold_char); \
        (yy_c_buf_p) = yytext + yyless_macro_arg; \
        (yy_hold_char) = *(yy_c_buf_p); \
        *(yy_c_buf_p) = '\0'; \
		yyleng = yyless_macro_arg; \
        } \
	while ( 0 )

Definition at line 1947 of file XdlScanner.cpp.

#define yymore ( ) yymore_used_but_not_detected

Definition at line 559 of file XdlScanner.cpp.

#define YYSTATE YY_START

Definition at line 143 of file XdlScanner.cpp.

#define YYTABLES_NAME "yytables"

Definition at line 2009 of file XdlScanner.cpp.

#define yyterminate ( ) return token::END

By default, yylex() returns int, but we want token_type instead. Unfortunately, yyterminate returns 0 by default, which is not of token_type.

Definition at line 604 of file XdlScanner.cpp.

#define yytext_ptr yytext

Definition at line 309 of file XdlScanner.cpp.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 56 of file XdlScanner.cpp.

typedef int flex_int32_t

Definition at line 57 of file XdlScanner.cpp.

typedef signed char flex_int8_t

Definition at line 55 of file XdlScanner.cpp.

typedef unsigned short int flex_uint16_t

Definition at line 59 of file XdlScanner.cpp.

typedef unsigned int flex_uint32_t

Definition at line 60 of file XdlScanner.cpp.

typedef unsigned char flex_uint8_t

Definition at line 58 of file XdlScanner.cpp.

typedef torc::XdlParser::token token

Import the parser's token types into a local typedef.

Definition at line 599 of file XdlScanner.cpp.

typedef torc::XdlParser::token_type token_type

Definition at line 600 of file XdlScanner.cpp.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 164 of file XdlScanner.cpp.

typedef unsigned char YY_CHAR

Definition at line 307 of file XdlScanner.cpp.

typedef size_t yy_size_t

Definition at line 193 of file XdlScanner.cpp.

Function Documentation

if ( ! yy_init )

Definition at line 765 of file XdlScanner.cpp.

         {
         (yy_init) = 1;
 
 #ifdef YY_USER_INIT
         YY_USER_INIT;
 #endif
 
         /* Create the reject buffer large enough to save one state per allowed character. */
         if ( ! (yy_state_buf) )
             (yy_state_buf) = (yy_state_type *)Xdlalloc(YY_STATE_BUF_SIZE  );
             if ( ! (yy_state_buf) )
                 YY_FATAL_ERROR( "out of dynamic memory in yylex()" );
 
         if ( ! (yy_start) )
             (yy_start) = 1; /* first start state */
 
         if ( ! yyin )
             yyin = & std::cin;
 
         if ( ! yyout )
             yyout = & std::cout;
 
         if ( ! YY_CURRENT_BUFFER ) {
             yyensure_buffer_stack ();
             YY_CURRENT_BUFFER_LVALUE =
                 yy_create_buffer( yyin, YY_BUF_SIZE );
         }
 
         yy_load_buffer_state(  );
         }

Here is the call graph for this function:

int isatty ( int )

yylloc step ( )

Code belonging at the beginning of yylex().

while ( 1 )

Todo:: Need to avoid obscuring IDENTIFIER.

Definition at line 797 of file XdlScanner.cpp.

         {
         yy_cp = (yy_c_buf_p);
 
         /* Support of yytext. */
         *yy_cp = (yy_hold_char);
 
         /* yy_bp points to the position in yy_ch_buf of the start of
          * the current run.
          */
         yy_bp = yy_cp;
 
         yy_current_state = (yy_start);
 
         (yy_state_ptr) = (yy_state_buf);
         *(yy_state_ptr)++ = yy_current_state;
 
 yy_match:
         do
             {
             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                 {
                 yy_current_state = (int) yy_def[yy_current_state];
                 if ( yy_current_state >= 169 )
                     yy_c = yy_meta[(unsigned int) yy_c];
                 }
             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
             *(yy_state_ptr)++ = yy_current_state;
             ++yy_cp;
             }
         while ( yy_current_state != 168 );
 
 yy_find_action:
         yy_current_state = *--(yy_state_ptr);
         (yy_lp) = yy_accept[yy_current_state];
 find_rule: /* we branch to this label when backing up */
         for ( ; ; ) /* until we find what rule we matched */
             {
             if ( (yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1] )
                 {
                 yy_act = yy_acclist[(yy_lp)];
                     {
                     (yy_full_match) = yy_cp;
                     break;
                     }
                 }
             --yy_cp;
             yy_current_state = *--(yy_state_ptr);
             (yy_lp) = yy_accept[yy_current_state];
             }
 
         YY_DO_BEFORE_ACTION;
 
 do_action:  /* This label is used only to access EOF actions. */
 
         switch ( yy_act )
     { /* beginning of action switch */
 case 1:
 YY_RULE_SETUP
 #line 119 "scanner.ll"
 { return token::BIDIRUNBUF; }   // == Bidirectional, unbuffered
     YY_BREAK
 case 2:
 YY_RULE_SETUP
 #line 120 "scanner.ll"
 { return token::BIDIRUNIBUF; }  // => Bidirectional, buf in one direction
     YY_BREAK
 case 3:
 YY_RULE_SETUP
 #line 121 "scanner.ll"
 { return token::BIDIRBIBUF; }   // =- Bidirectional, buf in both directions
     YY_BREAK
 case 4:
 YY_RULE_SETUP
 #line 122 "scanner.ll"
 { return token::UNIDIRBUF; }    // -> Directional, buffered
     YY_BREAK
 case 5:
 YY_RULE_SETUP
 #line 124 "scanner.ll"
 { return token::DESIGN; }
     YY_BREAK
 case 6:
 YY_RULE_SETUP
 #line 125 "scanner.ll"
 { return token::MODULE; }
     YY_BREAK
 case 7:
 YY_RULE_SETUP
 #line 126 "scanner.ll"
 { return token::ENDMODULE; }
     YY_BREAK
 case 8:
 YY_RULE_SETUP
 #line 127 "scanner.ll"
 { return token::PORT; }
     YY_BREAK
 case 9:
 YY_RULE_SETUP
 #line 128 "scanner.ll"
 { return token::INST; }
     YY_BREAK
 case 10:
 YY_RULE_SETUP
 #line 129 "scanner.ll"
 { return token::NET; }
     YY_BREAK
 case 11:
 YY_RULE_SETUP
 #line 131 "scanner.ll"
 { 
 ;                         BEGIN CONFIGSTRING; quote = colon = 0; yyless(yyleng-1); 
 ;                         return token::CFG; 
 ;                       }
     YY_BREAK
 case 12:
 YY_RULE_SETUP
 #line 135 "scanner.ll"
 { 
 ;                         quote++; if(quote == 2) BEGIN INITIAL; /* must have been an empty config*/
 ;                         return static_cast<token_type>('"'); 
 ;                       }
     YY_BREAK
 case 13:
 YY_RULE_SETUP
 #line 139 "scanner.ll"
 { /* discard whitespace */ }
     YY_BREAK
 case 14:
 /* rule 14 can match eol */
 YY_RULE_SETUP
 #line 140 "scanner.ll"
 { yylloc->lines(); /* discard whitespace */ }
     YY_BREAK
 case 15:
 YY_RULE_SETUP
 #line 141 "scanner.ll"
 { 
 ;                         colon++; if(colon == 2) BEGIN CONFIGSTRING2; 
 ;                         return static_cast<token_type>(':'); 
 ;                       }
     YY_BREAK
 case 16:
 YY_RULE_SETUP
 #line 145 "scanner.ll"
 { 
 ;                         *yylval = yytext; return colon == 0 ? token::CFGSETTING : token::CFGNAME; 
 ;                       }
     YY_BREAK
 case 17:
 YY_RULE_SETUP
 #line 148 "scanner.ll"
 { *yylval = yytext; return token::CFGVALUE; }
     YY_BREAK
 case 18:
 /* rule 18 can match eol */
 YY_RULE_SETUP
 #line 149 "scanner.ll"
 { 
 ;                         /* account for newlines embedded within trailing whitespace */
 ;                         for(char* ptr = yytext; *ptr != 0; ptr++) { 
 ;                           if(*ptr == 0) break; 
 ;                           if(false && *ptr == '\n') yylloc->lines();
 ;                         } 
 ;                         colon = 0; BEGIN INITIAL; return static_cast<token_type>('"'); 
 ;                       }
     YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 157 "scanner.ll"
 { colon = 0; BEGIN CONFIGSTRING; }
     YY_BREAK
 case 20:
 /* rule 20 can match eol */
 YY_RULE_SETUP
 #line 158 "scanner.ll"
 { yylloc->lines(); /* discard whitespace */ }
     YY_BREAK
 case 21:
 YY_RULE_SETUP
 #line 160 "scanner.ll"
 { return token::PLACED; }
     YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 161 "scanner.ll"
 { return token::UNPLACED; }
     YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 162 "scanner.ll"
 { return token::BONDED; }
     YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 163 "scanner.ll"
 { return token::UNBONDED; }
     YY_BREAK
 case 25:
 YY_RULE_SETUP
 #line 164 "scanner.ll"
 { return token::POWER; }
     YY_BREAK
 case 26:
 YY_RULE_SETUP
 #line 165 "scanner.ll"
 { return token::GROUND; }
     YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 166 "scanner.ll"
 { return token::INPIN; }
     YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 167 "scanner.ll"
 { return token::OUTPIN; }
     YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 168 "scanner.ll"
 { return token::PIP; }
     YY_BREAK
 case 30:
 YY_RULE_SETUP
 #line 169 "scanner.ll"
 { *yylval = yytext; return token::SPEEDGRADE; }
     YY_BREAK
 case 31:
 YY_RULE_SETUP
 #line 170 "scanner.ll"
 { *yylval = yytext; return token::XDLVERSION; 
                             /** \todo Need to avoid obscuring IDENTIFIER. */ }
     YY_BREAK
 case 32:
 YY_RULE_SETUP
 #line 172 "scanner.ll"
 { *yylval = yytext; return token::IDENTIFIER; }
     YY_BREAK
 case 33:
 YY_RULE_SETUP
 #line 173 "scanner.ll"
 { return token::OBRACE; }
     YY_BREAK
 case 34:
 YY_RULE_SETUP
 #line 174 "scanner.ll"
 { return token::EBRACE; }
     YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 176 "scanner.ll"
 { 
 ;                         DEBUG(("ROUTETHROUGH "));
 ;                         // be sure to strip the leading hash and spaces from the token
 ;                         char* ptr = yytext + 1;
 ;                         char* end = ptr + yyleng;
 ;                         while(*ptr == ' ' && ptr < end) ptr++;
 ;                         *yylval = ptr;
 ;                         return token::ROUTETHROUGH;
 ;                       }
     YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 185 "scanner.ll"
 { // be careful not to let _ROUTETHROUGH expressions pass for comments
 ;                         char* ptr = yytext + 1;
 ;                         char* end = ptr + yyleng;
 ;                         while((*ptr == ' ' || *ptr == '\t') && ptr < end) ptr++;
 ;                         if((end - ptr > 13) && strncmp(ptr, "_ROUTETHROUGH", 13) == 0) REJECT;
 ;                         // okay, this really is a comment
 ;                         DEBUG(("COMMENT "));
 ;                       }
     YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 194 "scanner.ll"
 { 
 ;                         BEGIN DOUBLEQUOTE; in_double_quote = true; last_string = ""; 
 ;                         /* enter exclusive quoted string state */
 ;                         return static_cast<token_type>(yytext[0]);
 ;                       }
     YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 199 "scanner.ll"
 { 
 ;                         last_string += yytext; 
 ;                         return token::STRING; /* append escaped characters to the input */ 
 ;                       }
     YY_BREAK
 case 39:
 /* rule 39 can match eol */
 YY_RULE_SETUP
 #line 203 "scanner.ll"
 { yylloc->lines(); /* ignore unescaped line breaks */ }
     YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 204 "scanner.ll"
 { 
 ;                         last_string += yytext; 
 ;                         return token::STRING; /* append characters other than \, ", \n, \r */ 
 ;                       }
     YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 208 "scanner.ll"
 { if(!in_double_quote) {
 ;                           BEGIN INITIAL; /* exit the exclusive quoted string state */
 ;                           DEBUG(("\" "));
 ;                           return static_cast<token_type>('"');
 ;                         }
 ;                         in_double_quote = false; /* we're no longer in double-quote mode */
 ;                         yylloc->end.columns(-1); 
 ;                         yyless(yyleng-1); /* push back the trailing double quote */
 ;                         //DEBUG(("[%s: length %d]\n", last_string.c_str(), last_string.length()));
 ;                         return token::STRING; /* and return the STRING token */
 ;                       }
     YY_BREAK
 case 42:
 /* rule 42 can match eol */
 YY_RULE_SETUP
 #line 220 "scanner.ll"
 { yylloc->lines(); }
     YY_BREAK
 case 43:
 YY_RULE_SETUP
 #line 221 "scanner.ll"
 { }
     YY_BREAK
 case 44:
 YY_RULE_SETUP
 #line 222 "scanner.ll"
 { return static_cast<token_type>(*yytext); }
     YY_BREAK
 /* --------------------------------------------------------------------------------------------- */
 /* ------------------------------------- End XDL lexer rules ----------------------------------- */
 /* --------------------------------------------------------------------------------------------- */
 case 45:
 YY_RULE_SETUP
 #line 231 "scanner.ll"
 ECHO;
     YY_BREAK
 #line 1143 "XdlScanner.cpp"
             case YY_STATE_EOF(INITIAL):
             case YY_STATE_EOF(CONFIGSTRING):
             case YY_STATE_EOF(CONFIGSTRING2):
             case YY_STATE_EOF(DOUBLEQUOTE):
                 yyterminate();
 
     case YY_END_OF_BUFFER:
         {
         /* Amount of text matched not including the EOB char. */
         int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
 
         /* Undo the effects of YY_DO_BEFORE_ACTION. */
         *yy_cp = (yy_hold_char);
         YY_RESTORE_YY_MORE_OFFSET
 
         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
             {
             /* We're scanning a new file or input source.  It's
              * possible that this happened because the user
              * just pointed yyin at a new source and called
              * yylex().  If so, then we have to assure
              * consistency between YY_CURRENT_BUFFER and our
              * globals.  Here is the right place to do so, because
              * this is the first action (other than possibly a
              * back-up) that will match for the new input source.
              */
             (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
             YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
             YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
             }
 
         /* Note that here we test for yy_c_buf_p "<=" to the position
          * of the first EOB in the buffer, since yy_c_buf_p will
          * already have been incremented past the NUL character
          * (since all states make transitions on EOB to the
          * end-of-buffer state).  Contrast this with the test
          * in input().
          */
         if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
             { /* This was really a NUL. */
             yy_state_type yy_next_state;
 
             (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
 
             yy_current_state = yy_get_previous_state(  );
 
             /* Okay, we're now positioned to make the NUL
              * transition.  We couldn't have
              * yy_get_previous_state() go ahead and do it
              * for us because it doesn't know how to deal
              * with the possibility of jamming (and we don't
              * want to build jamming into it because then it
              * will run more slowly).
              */
 
             yy_next_state = yy_try_NUL_trans( yy_current_state );
 
             yy_bp = (yytext_ptr) + YY_MORE_ADJ;
 
             if ( yy_next_state )
                 {
                 /* Consume the NUL. */
                 yy_cp = ++(yy_c_buf_p);
                 yy_current_state = yy_next_state;
                 goto yy_match;
                 }
 
             else
                 {
                 yy_cp = (yy_c_buf_p);
                 goto yy_find_action;
                 }
             }
 
         else switch ( yy_get_next_buffer(  ) )
             {
             case EOB_ACT_END_OF_FILE:
                 {
                 (yy_did_buffer_switch_on_eof) = 0;
 
                 if ( yywrap(  ) )
                     {
                     /* Note: because we've taken care in
                      * yy_get_next_buffer() to have set up
                      * yytext, we can now set up
                      * yy_c_buf_p so that if some total
                      * hoser (like flex itself) wants to
                      * call the scanner after we return the
                      * YY_NULL, it'll still work - another
                      * YY_NULL will get returned.
                      */
                     (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
 
                     yy_act = YY_STATE_EOF(YY_START);
                     goto do_action;
                     }
 
                 else
                     {
                     if ( ! (yy_did_buffer_switch_on_eof) )
                         YY_NEW_FILE;
                     }
                 break;
                 }
 
             case EOB_ACT_CONTINUE_SCAN:
                 (yy_c_buf_p) =
                     (yytext_ptr) + yy_amount_of_matched_text;
 
                 yy_current_state = yy_get_previous_state(  );
 
                 yy_cp = (yy_c_buf_p);
                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                 goto yy_match;
 
             case EOB_ACT_LAST_MATCH:
                 (yy_c_buf_p) =
                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
 
                 yy_current_state = yy_get_previous_state(  );
 
                 yy_cp = (yy_c_buf_p);
                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                 goto yy_find_action;
             }
         break;
         }
 
     default:
         YY_FATAL_ERROR(
             "fatal flex scanner internal error--no action found" );
     } /* end of action switch */
         } /* end of scanning one token */

void * Xdlalloc ( yy_size_t size )

Bison lexer internals.

Definition at line 1987 of file XdlScanner.cpp.

 {
     return (void *) malloc( size );
 }

Here is the caller graph for this function:

void Xdlfree ( void * ptr )

Bison lexer internals.

Definition at line 2004 of file XdlScanner.cpp.

 {
     free( (char *) ptr );   /* see Xdlrealloc() for (char *) cast */
 }

void * Xdlrealloc	(	void *	ptr,
		yy_size_t	size
	)

Bison lexer internals.

Definition at line 1992 of file XdlScanner.cpp.

 {
     /* The cast to (char *) in the following accommodates both
      * implementations that use char* generic pointers, and those
      * that use void* generic pointers.  It works with the latter
      * because both ANSI C and C++ allow castless assignment from
      * any pointer type to void*, and deal with argument conversions
      * as though doing an assignment.
      */
     return (void *) realloc( (char *) ptr, size );
 }

Variable Documentation

yyconst flex_int16_t yy_accept[170]

static

Initial value:

=
    {   0,
        1,    1,    1,    1,    1,    1,    1,    2,    3,    4,
        6,    9,   11,   13,   16,   19,   21,   23,   26,   29,
       32,   35,   38,   41,   44,   47,   50,   53,   56,   59,
       62,   65,   68,   70,   72,   74,   75,   77,   79,   81,
       83,   85,   86,   88,   90,   92,   94,   95,   97,   98,
       99,  100,  101,  102,  103,  104,  105,  106,  107,  108,
      109,  110,  111,  112,  113,  114,  115,  116,  117,  118,
      119,  120,  121,  122,  123,  124,  125,  126,  127,  128,
      129,  130,  131,  131,  132,  133,  134,  135,  136,  137,
      138,  139,  140,  141,  142,  143,  145,  146,  147,  148,
      149,  151,  152,  154,  155,  156,  157,  158,  159,  160,
      162,  163,  164,  164,  165,  166,  167,  168,  170,  171,
      172,  173,  175,  176,  177,  178,  180,  181,  182,  183,
      184,  185,  186,  188,  189,  190,  191,  192,  193,  194,
      195,  197,  199,  200,  201,  203,  205,  207,  208,  209,
      210,  211,  212,  213,  214,  215,  216,  218,  220,  222,
      223,  225,  226,  227,  228,  229,  230,  232,  232
    }

Definition at line 362 of file XdlScanner.cpp.

yyconst flex_int16_t yy_acclist[232]

static

Initial value:

=
    {   0,
       40,   40,   46,   44,   45,   43,   44,   45,   42,   45,
       44,   45,   37,   44,   45,   36,   44,   45,   44,   45,
       44,   45,   32,   44,   45,   32,   44,   45,   32,   44,
       45,   32,   44,   45,   32,   44,   45,   32,   44,   45,
       32,   44,   45,   32,   44,   45,   32,   44,   45,   32,
       44,   45,   32,   44,   45,   32,   44,   45,   32,   44,
       45,   33,   44,   45,   34,   44,   45,   16,   45,   13,
       45,   14,   45,   45,   12,   45,   15,   45,   17,   45,
       19,   45,   20,   45,   45,   18,   45,   17,   45,   40,
       45,   39,   45,   45,   41,   45,   45,   43,   42,   36,
       36,   30,    4,    3,    1,    2,   32,   32,   32,   32,
       32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
       32,   32,   32,   32,   16,   13,   14,   17,   17,   19,
       18,   20,   17,   17,   40,   39,   38,   36,   32,   32,
       32,   32,   26,   32,   32,   32,   32,   32,   10,   32,
       32,   29,   32,   32,   32,   32,   32,   32,   32,   25,
       32,   36,   32,   32,   32,   32,   32,    9,   32,   32,
       32,   32,    8,   32,   32,   32,   32,   31,   32,   36,
       32,   11,   32,   32,   32,   27,   32,   32,   32,   32,
       32,   32,   32,   36,   23,   32,    5,   32,   32,   32,
        6,   32,   28,   32,   21,   32,   32,   32,   36,   32,
       32,   32,   32,   36,   32,    9,   32,   24,   32,   22,
       32,   36,    7,   32,   36,   36,   36,   36,   36,   35,
       36
    }

Definition at line 332 of file XdlScanner.cpp.

register int yy_act

Definition at line 735 of file XdlScanner.cpp.

yyconst flex_int16_t yy_base[179]

static

Initial value:

=
    {   0,
        0,    0,   42,   46,   55,   59,   50,   62,  277,  278,
      274,  278,  272,  278,  272,   60,   63,    0,  239,  244,
      244,  237,   45,  236,  234,  240,  227,   54,  232,   64,
      278,  278,    0,  262,  278,  260,  278,  278,  241,   89,
       93,   97,  278,  101,    0,  278,  258,  278,    0,  258,
      278,    0,   85,  250,  278,  278,  278,  278,    0,  225,
      228,  219,  229,  228,  219,   42,  226,  213,  212,  214,
      225,   68,   84,  102,  222,  220,    0,  243,  278,  223,
      110,  121,  125,  278,  130,  222,  116,    0,  278,  278,
      224,  215,  238,  209,  206,    0,  198,  206,  197,  195,
        0,  198,    0,  207,  193,  203,  195,  197,  218,    0,
      209,  198,  111,  195,  189,  189,  188,  197,  188,  188,
      190,    0,  180,  182,  191,  204,  192,  185,  278,  177,
      183,  182,    0,  174,  179,  172,  178,  177,  177,  182,
        0,    0,  161,  170,    0,    0,    0,  163,  162,  168,
      145,  148,  148,  145,  150,  141,    0,    0,    0,  151,
        0,  143,  119,   97,   71,   66,    0,  278,  137,  144,
      151,  158,   63,  165,  172,  179,  186,  192
    }

Definition at line 425 of file XdlScanner.cpp.

register char * yy_bp

Definition at line 734 of file XdlScanner.cpp.

yyconst flex_int16_t yy_chk[322]

static

Definition at line 511 of file XdlScanner.cpp.

register char* yy_cp

Definition at line 734 of file XdlScanner.cpp.

YY_DECL register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 733 of file XdlScanner.cpp.

yyconst flex_int16_t yy_def[179]

static

Initial value:

=
    {   0,
      168,    1,  169,  169,  170,  170,  171,  171,  168,  168,
      168,  168,  168,  168,  172,  168,  168,  173,  173,  173,
      173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
      168,  168,  174,  168,  168,  168,  168,  168,  175,  168,
      168,  168,  168,  176,  177,  168,  168,  168,  178,  168,
      168,  172,  172,  168,  168,  168,  168,  168,  173,  173,
      173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
      173,  173,  173,  173,  173,  173,  174,  168,  168,  175,
      176,  168,  168,  168,  168,  175,  176,  177,  168,  168,
      172,  173,  173,  173,  173,  173,  173,  173,  173,  173,
      173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
      172,  173,  168,  173,  173,  173,  173,  173,  173,  173,
      173,  173,  173,  173,  173,  173,  172,  173,  168,  173,
      173,  173,  173,  173,  173,  173,  173,  173,  173,  172,
      173,  173,  173,  173,  173,  173,  173,  173,  173,  172,
      173,  173,  173,  173,  172,  173,  173,  173,  173,  172,
      173,  172,  172,  172,  172,  172,  172,    0,  168,  168,
      168,  168,  168,  168,  168,  168,  168,  168
    }

Definition at line 448 of file XdlScanner.cpp.

yyconst flex_int32_t yy_ec[256]

static

Definition at line 384 of file XdlScanner.cpp.

yyconst flex_int32_t yy_meta[44]

static

Initial value:

=
    {   0,
        1,    2,    3,    4,    4,    1,    1,    5,    5,    6,
        1,    1,    5,    5,    5,    5,    5,    5,    5,    5,
        7,    5,    5,    5,    5,    5,    5,    5,    5,    5,
        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
        5,    1,    1
    }

Definition at line 416 of file XdlScanner.cpp.

yyconst flex_int16_t yy_nxt[322]

static

Definition at line 471 of file XdlScanner.cpp.

int yyleng

Data Structures

Namespaces

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation