torc-master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Data Structures | Namespaces | Macros | Typedefs | Functions | Variables
Scanner.cc File Reference
#include <cstdio>
#include <iostream>
#include <errno.h>
#include <cstdlib>
#include <cstring>
#include <FlexLexer.h>
#include <string>
#include "torc/generic/edif/ParserHelpers.hpp"
#include "torc/generic/PortAttributes.hpp"
#include "torc/generic/NetAttributes.hpp"
#include "torc/generic/edif/Parser.h"
#include "torc/generic/edif/Scanner.hpp"
#include "torc/generic/InterfaceAttributes.hpp"
#include "torc/generic/LogicValueAttributes.hpp"
+ Include dependency graph for Scanner.cc:

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::generic
 Namespace for the Torc generic netlist, including EDIF and BLIF importers and exporters.
 

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   EdifFlexLexer
 
#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 FLEX_DEBUG
 
#define yytext_ptr   yytext
 
#define YY_DO_BEFORE_ACTION
 
#define YY_NUM_RULES   298
 
#define YY_END_OF_BUFFER   299
 
#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
 
#define YY_USER_ACTION
 
#define INITIAL   0
 
#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::generic::Parser::token 		Token
 
typedef
torc::generic::Parser::token_type 		TokenType
 

Functions

void * Edifalloc (yy_size_t)
 
void * Edifrealloc (void *, yy_size_t)
 
void Ediffree (void *)
 
yylloc step ()
 
 if (!(yy_init))
 
 while (1)
 
int isatty (int)
 

Variables

int yyleng
 
static yyconst flex_int16_t yy_acclist [2063]
 
static yyconst flex_int16_t yy_accept [1722]
 
static yyconst flex_int32_t yy_ec [256]
 
static yyconst flex_int32_t yy_meta [71]
 
static yyconst flex_int16_t yy_base [1724]
 
static yyconst flex_int16_t yy_def [1724]
 
static yyconst flex_int16_t yy_nxt [3603]
 
static yyconst flex_int16_t yy_chk [3603]
 
static yyconst flex_int16_t yy_rule_linenum [298]
 
YY_DECL register yy_state_type yy_current_state
 
register char * yy_cp
 
register char * yy_bp
 
register int yy_act
 

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 175 of file Scanner.cc.

#define ECHO   LexerOutput(yytext, yyleng)

Definition at line 2234 of file Scanner.cc.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 215 of file Scanner.cc.

#define EOB_ACT_END_OF_FILE   1

Definition at line 216 of file Scanner.cc.

#define EOB_ACT_LAST_MATCH   2

Definition at line 217 of file Scanner.cc.

#define FLEX_BETA

Definition at line 23 of file Scanner.cc.

#define FLEX_DEBUG

Definition at line 376 of file Scanner.cc.

#define FLEX_SCANNER

Definition at line 18 of file Scanner.cc.

#define FLEXINT_H

Definition at line 56 of file Scanner.cc.

#define INITIAL   0

Definition at line 2171 of file Scanner.cc.

#define INT16_MAX   (32767)

Definition at line 99 of file Scanner.cc.

#define INT16_MIN   (-32767-1)

Definition at line 90 of file Scanner.cc.

#define INT32_MAX   (2147483647)

Definition at line 102 of file Scanner.cc.

#define INT32_MIN   (-2147483647-1)

Definition at line 93 of file Scanner.cc.

#define INT8_MAX   (127)

Definition at line 96 of file Scanner.cc.

#define INT8_MIN   (-128)

Definition at line 87 of file Scanner.cc.

#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; \
}
yy_cp
register char * yy_cp
Definition: Scanner.cc:2322

Definition at line 2104 of file Scanner.cc.

#define UINT16_MAX   (65535U)

Definition at line 108 of file Scanner.cc.

#define UINT32_MAX   (4294967295U)

Definition at line 111 of file Scanner.cc.

#define UINT8_MAX   (255U)

Definition at line 105 of file Scanner.cc.

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

Definition at line 235 of file Scanner.cc.

#define YY_AT_BOL ( )    (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 371 of file Scanner.cc.

#define YY_BREAK   break;

Definition at line 2308 of file Scanner.cc.

#define YY_BUF_SIZE   16384

Definition at line 194 of file Scanner.cc.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 307 of file Scanner.cc.

#define YY_BUFFER_NEW   0

Definition at line 295 of file Scanner.cc.

#define YY_BUFFER_NORMAL   1

Definition at line 296 of file Scanner.cc.

#define YY_CURRENT_BUFFER
Value:
((yy_buffer_stack) \
? (yy_buffer_stack)[(yy_buffer_stack_top)] \
: NULL)

Definition at line 327 of file Scanner.cc.

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 334 of file Scanner.cc.

#define YY_DECL   int yyFlexLexer::yylex()

Definition at line 2295 of file Scanner.cc.

#define YY_DECL_IS_OURS   1

Definition at line 2291 of file Scanner.cc.

#define YY_DO_BEFORE_ACTION
Value:
(yytext_ptr) = yy_bp; \
/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\
yyleng = (size_t) (yy_cp - yy_bp); \
(yy_hold_char) = *yy_cp; \
*yy_cp = '\0'; \
/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\
(yy_c_buf_p) = yy_cp;
yytext_ptr
#define yytext_ptr
Definition: Scanner.cc:380
yyleng
int yyleng
yy_cp
register char * yy_cp
Definition: Scanner.cc:2322
yy_bp
register char * yy_bp
Definition: Scanner.cc:2322

Definition at line 390 of file Scanner.cc.

#define YY_END_OF_BUFFER   299

Definition at line 401 of file Scanner.cc.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 190 of file Scanner.cc.

#define YY_EXIT_FAILURE   2

Definition at line 6930 of file Scanner.cc.

#define YY_EXTRA_TYPE   void *

Definition at line 2186 of file Scanner.cc.

#define YY_FATAL_ERROR (   msg)    LexerError(msg)

Definition at line 2270 of file Scanner.cc.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 19 of file Scanner.cc.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 20 of file Scanner.cc.

#define YY_FLEX_SUBMINOR_VERSION   35

Definition at line 21 of file Scanner.cc.

#define YY_INPUT (   buf,
  result,
  max_size 
)
Value:
/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\
\
/* %if-c++-only C++ definition \ */\
if ((result = LexerInput((char *) buf, max_size)) < 0 ) \
YY_FATAL_ERROR("input in flex scanner failed");
if
if(!(yy_init))
Definition: Scanner.cc:2337
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: Scanner.cc:2270

Definition at line 2242 of file Scanner.cc.

#define YY_INT_ALIGNED   short int

Definition at line 6 of file Scanner.cc.

#define YY_LESS_LINENO (   n)

Definition at line 219 of file Scanner.cc.

#define YY_MORE_ADJ   0

Definition at line 2113 of file Scanner.cc.

#define yy_new_buffer   yy_create_buffer

Definition at line 349 of file Scanner.cc.

#define YY_NEW_FILE   yyrestart(yyin)

Definition at line 188 of file Scanner.cc.

#define YY_NO_UNISTD_H

Definition at line 2153 of file Scanner.cc.

#define YY_NULL   0

Definition at line 151 of file Scanner.cc.

#define YY_NUM_RULES   298

Definition at line 400 of file Scanner.cc.

#define YY_READ_BUF_SIZE   8192

Definition at line 2226 of file Scanner.cc.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 2114 of file Scanner.cc.

#define YY_RULE_SETUP   YY_USER_ACTION

Definition at line 2312 of file Scanner.cc.

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

Definition at line 161 of file Scanner.cc.

#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; \
}
if
if(!(yy_init))
Definition: Scanner.cc:2337
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: Scanner.cc:327
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: Scanner.cc:194
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: Scanner.cc:334

Definition at line 361 of file Scanner.cc.

#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; \
}
if
if(!(yy_init))
Definition: Scanner.cc:2337
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: Scanner.cc:327
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: Scanner.cc:194
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: Scanner.cc:334

Definition at line 351 of file Scanner.cc.

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

Definition at line 181 of file Scanner.cc.

#define YY_START_STACK_INCR   25

Definition at line 2262 of file Scanner.cc.

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

Definition at line 199 of file Scanner.cc.

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

Definition at line 185 of file Scanner.cc.

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 243 of file Scanner.cc.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 202 of file Scanner.cc.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 238 of file Scanner.cc.

#define YY_USER_ACTION
Value:
{ yylloc->columns(yyleng); addToBuffer(yytext); \
yylloc->columns(yyleng); addToUserDataBuffer(yytext); \
}
yyleng
int yyleng

Definition at line 2166 of file Scanner.cc.

#define yyconst

Definition at line 145 of file Scanner.cc.

#define yyFlexLexer   EdifFlexLexer

Definition at line 33 of file Scanner.cc.

#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)
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: Scanner.cc:2113
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: Scanner.cc:2114
while
while(1)
Definition: Scanner.cc:2377
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: Scanner.cc:390
yy_cp
register char * yy_cp
Definition: Scanner.cc:2322
YY_LESS_LINENO
#define YY_LESS_LINENO(n)
Definition: Scanner.cc:219
yy_bp
register char * yy_bp
Definition: Scanner.cc:2322

Definition at line 6946 of file Scanner.cc.

#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)
while
while(1)
Definition: Scanner.cc:2377
yyleng
int yyleng
YY_LESS_LINENO
#define YY_LESS_LINENO(n)
Definition: Scanner.cc:219

Definition at line 6946 of file Scanner.cc.

#define yymore ( )    yymore_used_but_not_detected

Definition at line 2112 of file Scanner.cc.

#define YYSTATE   YY_START

Definition at line 182 of file Scanner.cc.

#define YYTABLES_NAME   "yytables"

Definition at line 7030 of file Scanner.cc.

#define yyterminate ( )    return Token::END

Definition at line 2149 of file Scanner.cc.

#define yytext_ptr   yytext

Definition at line 380 of file Scanner.cc.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 78 of file Scanner.cc.

typedef int flex_int32_t

Definition at line 79 of file Scanner.cc.

typedef signed char flex_int8_t

Definition at line 77 of file Scanner.cc.

typedef unsigned short int flex_uint16_t

Definition at line 81 of file Scanner.cc.

typedef unsigned int flex_uint32_t

Definition at line 82 of file Scanner.cc.

typedef unsigned char flex_uint8_t

Definition at line 80 of file Scanner.cc.

typedef torc::generic::Parser::token Token

Definition at line 2144 of file Scanner.cc.

typedef torc::generic::Parser::token_type TokenType

Definition at line 2145 of file Scanner.cc.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 203 of file Scanner.cc.

typedef unsigned char YY_CHAR

Definition at line 378 of file Scanner.cc.

typedef size_t yy_size_t

Definition at line 239 of file Scanner.cc.

Function Documentation

void * Edifalloc ( yy_size_t  size)

Definition at line 7006 of file Scanner.cc.

7007 {
7008  return (void *) malloc(size);
7009 }

+ Here is the caller graph for this function:

void Ediffree ( void *  ptr)

Definition at line 7023 of file Scanner.cc.

7024 {
7025  free((char *) ptr); /* see Edifrealloc() for (char *) cast */
7026 }
void * Edifrealloc ( void *  ptr,
yy_size_t  size 
)

Definition at line 7011 of file Scanner.cc.

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

Definition at line 2337 of file Scanner.cc.

2338  {
2339  (yy_init) = 1;
2340 
2341 #ifdef YY_USER_INIT
2342  YY_USER_INIT;
2343 #endif
2344 
2345  /* Create the reject buffer large enough to save one state per allowed character. */
2346  if (! (yy_state_buf))
2347  (yy_state_buf) = (yy_state_type *)Edifalloc(YY_STATE_BUF_SIZE );
2348  if (! (yy_state_buf))
2349  YY_FATAL_ERROR("out of dynamic memory in yylex()");
2350 
2351  if (! (yy_start))
2352  (yy_start) = 1; /* first start state */
2353 
2354  if (! yyin)
2355 /* %if-c-only */
2356 /* %endif */
2357 /* %if-c++-only */
2358  yyin = & std::cin;
2359 /* %endif */
2360 
2361  if (! yyout)
2362 /* %if-c-only */
2363 /* %endif */
2364 /* %if-c++-only */
2365  yyout = & std::cout;
2366 /* %endif */
2367 
2368  if (! YY_CURRENT_BUFFER) {
2369  yyensure_buffer_stack ();
2370  YY_CURRENT_BUFFER_LVALUE =
2371  yy_create_buffer(yyin, YY_BUF_SIZE);
2372  }
2373 
2374  yy_load_buffer_state();
2375  }
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: Scanner.cc:2270
Edifalloc
void * Edifalloc(yy_size_t)
Definition: Scanner.cc:7006
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: Scanner.cc:327
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: Scanner.cc:194
YY_STATE_BUF_SIZE
#define YY_STATE_BUF_SIZE
Definition: Scanner.cc:199
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: Scanner.cc:334

+ Here is the call graph for this function:

int isatty ( int  )
yylloc step ( )
while ( 1  )

Definition at line 2377 of file Scanner.cc.

2378  {
2379 /* %% [8.0] yymore()-related code goes here */
2380  yy_cp = (yy_c_buf_p);
2381 
2382  /* Support of yytext. */
2383  *yy_cp = (yy_hold_char);
2384 
2385  /* yy_bp points to the position in yy_ch_buf of the start of
2386  * the current run.
2387  */
2388  yy_bp = yy_cp;
2389 
2390 /* %% [9.0] code to set up and find next match goes here */
2391  yy_current_state = (yy_start);
2392 
2393  (yy_state_ptr) = (yy_state_buf);
2394  *(yy_state_ptr)++ = yy_current_state;
2395 
2396 yy_match:
2397  do
2398  {
2399  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
2400  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
2401  {
2402  yy_current_state = (int) yy_def[yy_current_state];
2403  if (yy_current_state >= 1721)
2404  yy_c = yy_meta[(unsigned int) yy_c];
2405  }
2406  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2407  *(yy_state_ptr)++ = yy_current_state;
2408  ++yy_cp;
2409  }
2410  while (yy_current_state != 1720);
2411 
2412 yy_find_action:
2413 /* %% [10.0] code to find the action number goes here */
2414  yy_current_state = *--(yy_state_ptr);
2415  (yy_lp) = yy_accept[yy_current_state];
2416 find_rule: /* we branch to this label when backing up */
2417  for (; ;) /* until we find what rule we matched */
2418  {
2419  if ((yy_lp) && (yy_lp) < yy_accept[yy_current_state + 1])
2420  {
2421  yy_act = yy_acclist[(yy_lp)];
2422  {
2423  (yy_full_match) = yy_cp;
2424  break;
2425  }
2426  }
2427  --yy_cp;
2428  yy_current_state = *--(yy_state_ptr);
2429  (yy_lp) = yy_accept[yy_current_state];
2430  }
2431 
2432  YY_DO_BEFORE_ACTION;
2433 
2434 /* %% [11.0] code for yylineno update goes here */
2435 
2436 do_action: /* This label is used only to access EOF actions. */
2437 
2438 /* %% [12.0] debug code goes here */
2439  if (yy_flex_debug)
2440  {
2441  if (yy_act == 0)
2442  std::cerr << "--scanner backing up\n";
2443  else if (yy_act < 298)
2444  std::cerr << "--accepting rule at line " << yy_rule_linenum[yy_act] <<
2445  "(\"" << yytext << "\")\n";
2446  else if (yy_act == 298)
2447  std::cerr << "--accepting default rule (\"" << yytext << "\")\n";
2448  else if (yy_act == 299)
2449  std::cerr << "--(end of buffer or a NUL)\n";
2450  else
2451  std::cerr << "--EOF (start condition " << YY_START << ")\n";
2452  }
2453 
2454  switch (yy_act)
2455  { /* beginning of action switch */
2456 /* %% [13.0] actions go here */
2457 case 1:
2458 YY_RULE_SETUP
2459 #line 88 "Scanner.ll"
2460 {
2461  setIsIdContext(false);
2462  return Token::LBKT;
2463  }
2464  YY_BREAK
2465 case 2:
2466 YY_RULE_SETUP
2467 #line 92 "Scanner.ll"
2468 { return Token::RBKT; }
2469  YY_BREAK
2470 case 3:
2471 YY_RULE_SETUP
2472 #line 93 "Scanner.ll"
2473 {
2474  if(getIsIdContext())
2475  {
2476  mIsIdAlreadyAdded = true;
2477  REJECT;
2478  }
2479  return Token::ANGLE;
2480  }
2481  YY_BREAK
2482 case 4:
2483 YY_RULE_SETUP
2484 #line 101 "Scanner.ll"
2485 {
2486  if(getIsIdContext())
2487  {
2488  mIsIdAlreadyAdded = true;
2489  REJECT;
2490  }
2491  return Token::BEHAVIOR;
2492  }
2493  YY_BREAK
2494 case 5:
2495 YY_RULE_SETUP
2496 #line 109 "Scanner.ll"
2497 {
2498  if(getIsIdContext())
2499  {
2500  mIsIdAlreadyAdded = true;
2501  REJECT;
2502  }
2503  return Token::CALCULATED;
2504  }
2505  YY_BREAK
2506 case 6:
2507 YY_RULE_SETUP
2508 #line 117 "Scanner.ll"
2509 {
2510  if(getIsIdContext())
2511  {
2512  mIsIdAlreadyAdded = true;
2513  REJECT;
2514  }
2515  return Token::CAPACITANCE;
2516  }
2517  YY_BREAK
2518 case 7:
2519 YY_RULE_SETUP
2520 #line 125 "Scanner.ll"
2521 {
2522  if(getIsIdContext())
2523  {
2524  mIsIdAlreadyAdded = true;
2525  REJECT;
2526  }
2527  return Token::CENTERCENTER;
2528  }
2529  YY_BREAK
2530 case 8:
2531 YY_RULE_SETUP
2532 #line 133 "Scanner.ll"
2533 {
2534  if(getIsIdContext())
2535  {
2536  mIsIdAlreadyAdded = true;
2537  REJECT;
2538  }
2539  return Token::CENTERLEFT;
2540  }
2541  YY_BREAK
2542 case 9:
2543 YY_RULE_SETUP
2544 #line 141 "Scanner.ll"
2545 {
2546  if(getIsIdContext())
2547  {
2548  mIsIdAlreadyAdded = true;
2549  REJECT;
2550  }
2551  return Token::CENTERRIGHT;
2552  }
2553  YY_BREAK
2554 case 10:
2555 YY_RULE_SETUP
2556 #line 149 "Scanner.ll"
2557 {
2558  if(getIsIdContext())
2559  {
2560  mIsIdAlreadyAdded = true;
2561  REJECT;
2562  }
2563  return Token::CHARGE;
2564  }
2565  YY_BREAK
2566 case 11:
2567 YY_RULE_SETUP
2568 #line 157 "Scanner.ll"
2569 {
2570  if(getIsIdContext())
2571  {
2572  mIsIdAlreadyAdded = true;
2573  REJECT;
2574  }
2575  return Token::CONDUCTANCE;
2576  }
2577  YY_BREAK
2578 case 12:
2579 YY_RULE_SETUP
2580 #line 165 "Scanner.ll"
2581 {
2582  if(getIsIdContext())
2583  {
2584  mIsIdAlreadyAdded = true;
2585  REJECT;
2586  }
2587  return Token::CURRENT;
2588  }
2589  YY_BREAK
2590 case 13:
2591 YY_RULE_SETUP
2592 #line 173 "Scanner.ll"
2593 {
2594  if(getIsIdContext())
2595  {
2596  mIsIdAlreadyAdded = true;
2597  REJECT;
2598  }
2599  return Token::DISTANCE;
2600  }
2601  YY_BREAK
2602 case 14:
2603 YY_RULE_SETUP
2604 #line 181 "Scanner.ll"
2605 {
2606  if(getIsIdContext())
2607  {
2608  mIsIdAlreadyAdded = true;
2609  REJECT;
2610  }
2611  return Token::DOCUMENT;
2612  }
2613  YY_BREAK
2614 case 15:
2615 YY_RULE_SETUP
2616 #line 189 "Scanner.ll"
2617 {
2618  if(getIsIdContext())
2619  {
2620  mIsIdAlreadyAdded = true;
2621  REJECT;
2622  }
2623  return Token::ENERGY;
2624  }
2625  YY_BREAK
2626 case 16:
2627 YY_RULE_SETUP
2628 #line 197 "Scanner.ll"
2629 {
2630  if(getIsIdContext())
2631  {
2632  mIsIdAlreadyAdded = true;
2633  REJECT;
2634  }
2635  return Token::EXTEND;
2636  }
2637  YY_BREAK
2638 case 17:
2639 YY_RULE_SETUP
2640 #line 205 "Scanner.ll"
2641 {
2642  if(getIsIdContext())
2643  {
2644  mIsIdAlreadyAdded = true;
2645  REJECT;
2646  }
2647  return Token::FLUX;
2648  }
2649  YY_BREAK
2650 case 18:
2651 YY_RULE_SETUP
2652 #line 213 "Scanner.ll"
2653 {
2654  if(getIsIdContext())
2655  {
2656  mIsIdAlreadyAdded = true;
2657  REJECT;
2658  }
2659  return Token::FREQUENCY;
2660  }
2661  YY_BREAK
2662 case 19:
2663 YY_RULE_SETUP
2664 #line 221 "Scanner.ll"
2665 {
2666  if(getIsIdContext())
2667  {
2668  mIsIdAlreadyAdded = true;
2669  REJECT;
2670  }
2671  return Token::GENERIC;
2672  }
2673  YY_BREAK
2674 case 20:
2675 YY_RULE_SETUP
2676 #line 229 "Scanner.ll"
2677 {
2678  if(getIsIdContext())
2679  {
2680  mIsIdAlreadyAdded = true;
2681  REJECT;
2682  }
2683  return Token::GRAPHIC;
2684  }
2685  YY_BREAK
2686 case 21:
2687 YY_RULE_SETUP
2688 #line 237 "Scanner.ll"
2689 {
2690  if(getIsIdContext())
2691  {
2692  mIsIdAlreadyAdded = true;
2693  REJECT;
2694  }
2695  return Token::INDUCTANCE;
2696  }
2697  YY_BREAK
2698 case 22:
2699 YY_RULE_SETUP
2700 #line 245 "Scanner.ll"
2701 {
2702  if(getIsIdContext())
2703  {
2704  mIsIdAlreadyAdded = true;
2705  REJECT;
2706  }
2707  return Token::INOUT;
2708  }
2709  YY_BREAK
2710 case 23:
2711 YY_RULE_SETUP
2712 #line 253 "Scanner.ll"
2713 {
2714  if(getIsIdContext())
2715  {
2716  mIsIdAlreadyAdded = true;
2717  REJECT;
2718  }
2719  return Token::INPUT;
2720  }
2721  YY_BREAK
2722 case 24:
2723 YY_RULE_SETUP
2724 #line 261 "Scanner.ll"
2725 {
2726  if(getIsIdContext())
2727  {
2728  mIsIdAlreadyAdded = true;
2729  REJECT;
2730  }
2731  return Token::LOGICMODEL;
2732  }
2733  YY_BREAK
2734 case 25:
2735 YY_RULE_SETUP
2736 #line 269 "Scanner.ll"
2737 {
2738  if(getIsIdContext())
2739  {
2740  mIsIdAlreadyAdded = true;
2741  REJECT;
2742  }
2743  return Token::LOWERCENTER;
2744  }
2745  YY_BREAK
2746 case 26:
2747 YY_RULE_SETUP
2748 #line 277 "Scanner.ll"
2749 {
2750  if(getIsIdContext())
2751  {
2752  mIsIdAlreadyAdded = true;
2753  REJECT;
2754  }
2755  return Token::LOWERLEFT;
2756  }
2757  YY_BREAK
2758 case 27:
2759 YY_RULE_SETUP
2760 #line 285 "Scanner.ll"
2761 {
2762  if(getIsIdContext())
2763  {
2764  mIsIdAlreadyAdded = true;
2765  REJECT;
2766  }
2767  return Token::LOWERRIGHT;
2768  }
2769  YY_BREAK
2770 case 28:
2771 YY_RULE_SETUP
2772 #line 293 "Scanner.ll"
2773 {
2774  if(getIsIdContext())
2775  {
2776  mIsIdAlreadyAdded = true;
2777  REJECT;
2778  }
2779  return Token::MASKLAYOUT;
2780  }
2781  YY_BREAK
2782 case 29:
2783 YY_RULE_SETUP
2784 #line 301 "Scanner.ll"
2785 {
2786  if(getIsIdContext())
2787  {
2788  mIsIdAlreadyAdded = true;
2789  REJECT;
2790  }
2791  return Token::MASS;
2792  }
2793  YY_BREAK
2794 case 30:
2795 YY_RULE_SETUP
2796 #line 309 "Scanner.ll"
2797 {
2798  if(getIsIdContext())
2799  {
2800  mIsIdAlreadyAdded = true;
2801  REJECT;
2802  }
2803  return Token::MEASURED;
2804  }
2805  YY_BREAK
2806 case 31:
2807 YY_RULE_SETUP
2808 #line 317 "Scanner.ll"
2809 {
2810  if(getIsIdContext())
2811  {
2812  mIsIdAlreadyAdded = true;
2813  REJECT;
2814  }
2815  return Token::MX;
2816  }
2817  YY_BREAK
2818 case 32:
2819 YY_RULE_SETUP
2820 #line 325 "Scanner.ll"
2821 {
2822  if(getIsIdContext())
2823  {
2824  mIsIdAlreadyAdded = true;
2825  REJECT;
2826  }
2827  return Token::MXR90;
2828  }
2829  YY_BREAK
2830 case 33:
2831 YY_RULE_SETUP
2832 #line 333 "Scanner.ll"
2833 {
2834  if(getIsIdContext())
2835  {
2836  mIsIdAlreadyAdded = true;
2837  REJECT;
2838  }
2839  return Token::MY;
2840  }
2841  YY_BREAK
2842 case 34:
2843 YY_RULE_SETUP
2844 #line 341 "Scanner.ll"
2845 {
2846  if(getIsIdContext())
2847  {
2848  mIsIdAlreadyAdded = true;
2849  REJECT;
2850  }
2851  return Token::MYR90;
2852  }
2853  YY_BREAK
2854 case 35:
2855 YY_RULE_SETUP
2856 #line 349 "Scanner.ll"
2857 {
2858  if(getIsIdContext())
2859  {
2860  mIsIdAlreadyAdded = true;
2861  REJECT;
2862  }
2863  setIsIdContext(true);
2864  return Token::NETLIST;
2865  }
2866  YY_BREAK
2867 case 36:
2868 YY_RULE_SETUP
2869 #line 358 "Scanner.ll"
2870 {
2871  if(getIsIdContext())
2872  {
2873  mIsIdAlreadyAdded = true;
2874  REJECT;
2875  }
2876  return Token::OUTPUT;
2877  }
2878  YY_BREAK
2879 case 37:
2880 YY_RULE_SETUP
2881 #line 366 "Scanner.ll"
2882 {
2883  if(getIsIdContext())
2884  {
2885  mIsIdAlreadyAdded = true;
2886  REJECT;
2887  }
2888  return Token::PCBLAYOUT;
2889  }
2890  YY_BREAK
2891 case 38:
2892 YY_RULE_SETUP
2893 #line 374 "Scanner.ll"
2894 {
2895  if(getIsIdContext())
2896  {
2897  mIsIdAlreadyAdded = true;
2898  REJECT;
2899  }
2900  return Token::POWER;
2901  }
2902  YY_BREAK
2903 case 39:
2904 YY_RULE_SETUP
2905 #line 382 "Scanner.ll"
2906 {
2907  if(getIsIdContext())
2908  {
2909  mIsIdAlreadyAdded = true;
2910  REJECT;
2911  }
2912  return Token::R0;
2913  }
2914  YY_BREAK
2915 case 40:
2916 YY_RULE_SETUP
2917 #line 390 "Scanner.ll"
2918 {
2919  if(getIsIdContext())
2920  {
2921  mIsIdAlreadyAdded = true;
2922  REJECT;
2923  }
2924  return Token::R180;
2925  }
2926  YY_BREAK
2927 case 41:
2928 YY_RULE_SETUP
2929 #line 398 "Scanner.ll"
2930 {
2931  if(getIsIdContext())
2932  {
2933  mIsIdAlreadyAdded = true;
2934  REJECT;
2935  }
2936  return Token::R270;
2937  }
2938  YY_BREAK
2939 case 42:
2940 YY_RULE_SETUP
2941 #line 406 "Scanner.ll"
2942 {
2943  if(getIsIdContext())
2944  {
2945  mIsIdAlreadyAdded = true;
2946  REJECT;
2947  }
2948  return Token::R90;
2949  }
2950  YY_BREAK
2951 case 43:
2952 YY_RULE_SETUP
2953 #line 414 "Scanner.ll"
2954 {
2955  if(getIsIdContext())
2956  {
2957  mIsIdAlreadyAdded = true;
2958  REJECT;
2959  }
2960  return Token::REQUIRED;
2961  }
2962  YY_BREAK
2963 case 44:
2964 YY_RULE_SETUP
2965 #line 422 "Scanner.ll"
2966 {
2967  if(getIsIdContext())
2968  {
2969  mIsIdAlreadyAdded = true;
2970  REJECT;
2971  }
2972  return Token::RESISTANCE;
2973  }
2974  YY_BREAK
2975 case 45:
2976 YY_RULE_SETUP
2977 #line 430 "Scanner.ll"
2978 {
2979  if(getIsIdContext())
2980  {
2981  mIsIdAlreadyAdded = true;
2982  REJECT;
2983  }
2984  return Token::RIPPER;
2985  }
2986  YY_BREAK
2987 case 46:
2988 YY_RULE_SETUP
2989 #line 438 "Scanner.ll"
2990 {
2991  if(getIsIdContext())
2992  {
2993  mIsIdAlreadyAdded = true;
2994  REJECT;
2995  }
2996  return Token::ROUND;
2997  }
2998  YY_BREAK
2999 case 47:
3000 YY_RULE_SETUP
3001 #line 446 "Scanner.ll"
3002 {
3003  if(getIsIdContext())
3004  {
3005  mIsIdAlreadyAdded = true;
3006  REJECT;
3007  }
3008  return Token::SCHEMATIC;
3009  }
3010  YY_BREAK
3011 case 48:
3012 YY_RULE_SETUP
3013 #line 454 "Scanner.ll"
3014 {
3015  if(getIsIdContext())
3016  {
3017  mIsIdAlreadyAdded = true;
3018  REJECT;
3019  }
3020  return Token::STRANGER;
3021  }
3022  YY_BREAK
3023 case 49:
3024 YY_RULE_SETUP
3025 #line 462 "Scanner.ll"
3026 {
3027  if(getIsIdContext())
3028  {
3029  mIsIdAlreadyAdded = true;
3030  REJECT;
3031  }
3032  return Token::SYMBOLIC;
3033  }
3034  YY_BREAK
3035 case 50:
3036 YY_RULE_SETUP
3037 #line 470 "Scanner.ll"
3038 {
3039  if(getIsIdContext())
3040  {
3041  mIsIdAlreadyAdded = true;
3042  REJECT;
3043  }
3044  return Token::TEMPERATURE;
3045  }
3046  YY_BREAK
3047 case 51:
3048 YY_RULE_SETUP
3049 #line 478 "Scanner.ll"
3050 {
3051  if(getIsIdContext())
3052  {
3053  mIsIdAlreadyAdded = true;
3054  REJECT;
3055  }
3056  return Token::TIE;
3057  }
3058  YY_BREAK
3059 case 52:
3060 YY_RULE_SETUP
3061 #line 486 "Scanner.ll"
3062 {
3063  if(getIsIdContext())
3064  {
3065  mIsIdAlreadyAdded = true;
3066  REJECT;
3067  }
3068  return Token::TIME;
3069  }
3070  YY_BREAK
3071 case 53:
3072 YY_RULE_SETUP
3073 #line 494 "Scanner.ll"
3074 {
3075  if(getIsIdContext())
3076  {
3077  mIsIdAlreadyAdded = true;
3078  REJECT;
3079  }
3080  return Token::TRUNCATE;
3081  }
3082  YY_BREAK
3083 case 54:
3084 YY_RULE_SETUP
3085 #line 502 "Scanner.ll"
3086 {
3087  if(getIsIdContext())
3088  {
3089  mIsIdAlreadyAdded = true;
3090  REJECT;
3091  }
3092  return Token::UPPERCENTER;
3093  }
3094  YY_BREAK
3095 case 55:
3096 YY_RULE_SETUP
3097 #line 510 "Scanner.ll"
3098 {
3099  if(getIsIdContext())
3100  {
3101  mIsIdAlreadyAdded = true;
3102  REJECT;
3103  }
3104  return Token::UPPERLEFT;
3105  }
3106  YY_BREAK
3107 case 56:
3108 YY_RULE_SETUP
3109 #line 518 "Scanner.ll"
3110 {
3111  if(getIsIdContext())
3112  {
3113  mIsIdAlreadyAdded = true;
3114  REJECT;
3115  }
3116  return Token::UPPERRIGHT;
3117  }
3118  YY_BREAK
3119 case 57:
3120 YY_RULE_SETUP
3121 #line 526 "Scanner.ll"
3122 {
3123  if(getIsIdContext())
3124  {
3125  mIsIdAlreadyAdded = true;
3126  REJECT;
3127  }
3128  return Token::VOLTAGE;
3129  }
3130  YY_BREAK
3131 case 58:
3132 YY_RULE_SETUP
3133 #line 535 "Scanner.ll"
3134 {
3135  if(getIsIdContext())
3136  {
3137  mIsIdAlreadyAdded = true;
3138  REJECT;
3139  }
3140  return Token::ACLOAD;
3141  }
3142  YY_BREAK
3143 case 59:
3144 YY_RULE_SETUP
3145 #line 543 "Scanner.ll"
3146 {
3147  if(getIsIdContext())
3148  {
3149  mIsIdAlreadyAdded = true;
3150  REJECT;
3151  }
3152  return Token::AFTER;
3153  }
3154  YY_BREAK
3155 case 60:
3156 YY_RULE_SETUP
3157 #line 551 "Scanner.ll"
3158 {
3159  if(getIsIdContext())
3160  {
3161  mIsIdAlreadyAdded = true;
3162  REJECT;
3163  }
3164  return Token::ANNOTATE;
3165  }
3166  YY_BREAK
3167 case 61:
3168 YY_RULE_SETUP
3169 #line 559 "Scanner.ll"
3170 {
3171  if(getIsIdContext())
3172  {
3173  mIsIdAlreadyAdded = true;
3174  REJECT;
3175  }
3176  return Token::APPLY;
3177  }
3178  YY_BREAK
3179 case 62:
3180 YY_RULE_SETUP
3181 #line 567 "Scanner.ll"
3182 {
3183  if(getIsIdContext())
3184  {
3185  mIsIdAlreadyAdded = true;
3186  REJECT;
3187  }
3188  return Token::ARC;
3189  }
3190  YY_BREAK
3191 case 63:
3192 YY_RULE_SETUP
3193 #line 575 "Scanner.ll"
3194 {
3195  if(getIsIdContext())
3196  {
3197  mIsIdAlreadyAdded = true;
3198  REJECT;
3199  }
3200  setIsIdContext(true);
3201  return Token::ARRAY;
3202  }
3203  YY_BREAK
3204 case 64:
3205 YY_RULE_SETUP
3206 #line 584 "Scanner.ll"
3207 {
3208  if(getIsIdContext())
3209  {
3210  mIsIdAlreadyAdded = true;
3211  REJECT;
3212  }
3213  return Token::ARRAYMACRO;
3214  }
3215  YY_BREAK
3216 case 65:
3217 YY_RULE_SETUP
3218 #line 592 "Scanner.ll"
3219 {
3220  if(getIsIdContext())
3221  {
3222  mIsIdAlreadyAdded = true;
3223  REJECT;
3224  }
3225  return Token::ARRAYRELATEDINFO;
3226  }
3227  YY_BREAK
3228 case 66:
3229 YY_RULE_SETUP
3230 #line 600 "Scanner.ll"
3231 {
3232  if(getIsIdContext())
3233  {
3234  mIsIdAlreadyAdded = true;
3235  REJECT;
3236  }
3237  return Token::ARRAYSITE;
3238  }
3239  YY_BREAK
3240 case 67:
3241 YY_RULE_SETUP
3242 #line 608 "Scanner.ll"
3243 {
3244  if(getIsIdContext())
3245  {
3246  mIsIdAlreadyAdded = true;
3247  REJECT;
3248  }
3249  return Token::ATLEAST;
3250  }
3251  YY_BREAK
3252 case 68:
3253 YY_RULE_SETUP
3254 #line 616 "Scanner.ll"
3255 {
3256  if(getIsIdContext())
3257  {
3258  mIsIdAlreadyAdded = true;
3259  REJECT;
3260  }
3261  return Token::ATMOST;
3262  }
3263  YY_BREAK
3264 case 69:
3265 YY_RULE_SETUP
3266 #line 624 "Scanner.ll"
3267 {
3268  if(getIsIdContext())
3269  {
3270  mIsIdAlreadyAdded = true;
3271  REJECT;
3272  }
3273  return Token::AUTHOR;
3274  }
3275  YY_BREAK
3276 case 70:
3277 YY_RULE_SETUP
3278 #line 632 "Scanner.ll"
3279 {
3280  if(getIsIdContext())
3281  {
3282  mIsIdAlreadyAdded = true;
3283  REJECT;
3284  }
3285  return Token::BASEARRAY;
3286  }
3287  YY_BREAK
3288 case 71:
3289 YY_RULE_SETUP
3290 #line 640 "Scanner.ll"
3291 {
3292  if(getIsIdContext())
3293  {
3294  mIsIdAlreadyAdded = true;
3295  REJECT;
3296  }
3297  return Token::BECOMES;
3298  }
3299  YY_BREAK
3300 case 72:
3301 YY_RULE_SETUP
3302 #line 648 "Scanner.ll"
3303 {
3304  if(getIsIdContext())
3305  {
3306  mIsIdAlreadyAdded = true;
3307  REJECT;
3308  }
3309  return Token::BETWEEN;
3310  }
3311  YY_BREAK
3312 case 73:
3313 YY_RULE_SETUP
3314 #line 656 "Scanner.ll"
3315 {
3316  if(getIsIdContext())
3317  {
3318  mIsIdAlreadyAdded = true;
3319  REJECT;
3320  }
3321  return Token::BOOLEAN;
3322  }
3323  YY_BREAK
3324 case 74:
3325 YY_RULE_SETUP
3326 #line 664 "Scanner.ll"
3327 {
3328  if(getIsIdContext())
3329  {
3330  mIsIdAlreadyAdded = true;
3331  REJECT;
3332  }
3333  return Token::BOOLEANDISPLAY;
3334  }
3335  YY_BREAK
3336 case 75:
3337 YY_RULE_SETUP
3338 #line 672 "Scanner.ll"
3339 {
3340  if(getIsIdContext())
3341  {
3342  mIsIdAlreadyAdded = true;
3343  REJECT;
3344  }
3345  return Token::BOOLEANMAP;
3346  }
3347  YY_BREAK
3348 case 76:
3349 YY_RULE_SETUP
3350 #line 680 "Scanner.ll"
3351 {
3352  if(getIsIdContext())
3353  {
3354  mIsIdAlreadyAdded = true;
3355  REJECT;
3356  }
3357  return Token::BORDERPATTERN;
3358  }
3359  YY_BREAK
3360 case 77:
3361 YY_RULE_SETUP
3362 #line 688 "Scanner.ll"
3363 {
3364  if(getIsIdContext())
3365  {
3366  mIsIdAlreadyAdded = true;
3367  REJECT;
3368  }
3369  return Token::BORDERWIDTH;
3370  }
3371  YY_BREAK
3372 case 78:
3373 YY_RULE_SETUP
3374 #line 696 "Scanner.ll"
3375 {
3376  if(getIsIdContext())
3377  {
3378  mIsIdAlreadyAdded = true;
3379  REJECT;
3380  }
3381  return Token::BOUNDINGBOX;
3382  }
3383  YY_BREAK
3384 case 79:
3385 YY_RULE_SETUP
3386 #line 704 "Scanner.ll"
3387 {
3388  if(getIsIdContext())
3389  {
3390  mIsIdAlreadyAdded = true;
3391  REJECT;
3392  }
3393  setIsIdContext(true);
3394  return Token::CELL;
3395  }
3396  YY_BREAK
3397 case 80:
3398 YY_RULE_SETUP
3399 #line 713 "Scanner.ll"
3400 {
3401  if(getIsIdContext())
3402  {
3403  mIsIdAlreadyAdded = true;
3404  REJECT;
3405  }
3406  setIsIdContext(true);
3407  return Token::CELLREF;
3408  }
3409  YY_BREAK
3410 case 81:
3411 YY_RULE_SETUP
3412 #line 722 "Scanner.ll"
3413 {
3414  if(getIsIdContext())
3415  {
3416  mIsIdAlreadyAdded = true;
3417  REJECT;
3418  }
3419  return Token::CELLTYPE;
3420  }
3421  YY_BREAK
3422 case 82:
3423 YY_RULE_SETUP
3424 #line 730 "Scanner.ll"
3425 {
3426  if(getIsIdContext())
3427  {
3428  mIsIdAlreadyAdded = true;
3429  REJECT;
3430  }
3431  return Token::CHANGE;
3432  }
3433  YY_BREAK
3434 case 83:
3435 YY_RULE_SETUP
3436 #line 738 "Scanner.ll"
3437 {
3438  if(getIsIdContext())
3439  {
3440  mIsIdAlreadyAdded = true;
3441  REJECT;
3442  }
3443  return Token::CIRCLE;
3444  }
3445  YY_BREAK
3446 case 84:
3447 YY_RULE_SETUP
3448 #line 746 "Scanner.ll"
3449 {
3450  if(getIsIdContext())
3451  {
3452  mIsIdAlreadyAdded = true;
3453  REJECT;
3454  }
3455  return Token::COLOR;
3456  }
3457  YY_BREAK
3458 case 85:
3459 YY_RULE_SETUP
3460 #line 754 "Scanner.ll"
3461 {
3462  if(getIsIdContext())
3463  {
3464  mIsIdAlreadyAdded = true;
3465  REJECT;
3466  }
3467  return Token::COMMENT;
3468  }
3469  YY_BREAK
3470 case 86:
3471 YY_RULE_SETUP
3472 #line 762 "Scanner.ll"
3473 {
3474  if(getIsIdContext())
3475  {
3476  mIsIdAlreadyAdded = true;
3477  REJECT;
3478  }
3479  return Token::COMMENTGRAPHICS;
3480  }
3481  YY_BREAK
3482 case 87:
3483 YY_RULE_SETUP
3484 #line 770 "Scanner.ll"
3485 {
3486  if(getIsIdContext())
3487  {
3488  mIsIdAlreadyAdded = true;
3489  REJECT;
3490  }
3491  return Token::COMPOUND;
3492  }
3493  YY_BREAK
3494 case 88:
3495 YY_RULE_SETUP
3496 #line 778 "Scanner.ll"
3497 {
3498  if(getIsIdContext())
3499  {
3500  mIsIdAlreadyAdded = true;
3501  REJECT;
3502  }
3503  return Token::CONNECTLOCATION;
3504  }
3505  YY_BREAK
3506 case 89:
3507 YY_RULE_SETUP
3508 #line 786 "Scanner.ll"
3509 {
3510  if(getIsIdContext())
3511  {
3512  mIsIdAlreadyAdded = true;
3513  REJECT;
3514  }
3515  return Token::CONTENTS;
3516  }
3517  YY_BREAK
3518 case 90:
3519 YY_RULE_SETUP
3520 #line 794 "Scanner.ll"
3521 {
3522  if(getIsIdContext())
3523  {
3524  mIsIdAlreadyAdded = true;
3525  REJECT;
3526  }
3527  return Token::CORNERTYPE;
3528  }
3529  YY_BREAK
3530 case 91:
3531 YY_RULE_SETUP
3532 #line 802 "Scanner.ll"
3533 {
3534  if(getIsIdContext())
3535  {
3536  mIsIdAlreadyAdded = true;
3537  REJECT;
3538  }
3539  return Token::CRITICALITY;
3540  }
3541  YY_BREAK
3542 case 92:
3543 YY_RULE_SETUP
3544 #line 810 "Scanner.ll"
3545 {
3546  if(getIsIdContext())
3547  {
3548  mIsIdAlreadyAdded = true;
3549  REJECT;
3550  }
3551  return Token::CURRENTMAP;
3552  }
3553  YY_BREAK
3554 case 93:
3555 YY_RULE_SETUP
3556 #line 818 "Scanner.ll"
3557 {
3558  if(getIsIdContext())
3559  {
3560  mIsIdAlreadyAdded = true;
3561  REJECT;
3562  }
3563  return Token::CURVE;
3564  }
3565  YY_BREAK
3566 case 94:
3567 YY_RULE_SETUP
3568 #line 826 "Scanner.ll"
3569 {
3570  if(getIsIdContext())
3571  {
3572  mIsIdAlreadyAdded = true;
3573  REJECT;
3574  }
3575  return Token::CYCLE;
3576  }
3577  YY_BREAK
3578 case 95:
3579 YY_RULE_SETUP
3580 #line 834 "Scanner.ll"
3581 {
3582  if(getIsIdContext())
3583  {
3584  mIsIdAlreadyAdded = true;
3585  REJECT;
3586  }
3587  return Token::DATAORIGIN;
3588  }
3589  YY_BREAK
3590 case 96:
3591 YY_RULE_SETUP
3592 #line 842 "Scanner.ll"
3593 {
3594  if(getIsIdContext())
3595  {
3596  mIsIdAlreadyAdded = true;
3597  REJECT;
3598  }
3599  return Token::DCFANINLOAD;
3600  }
3601  YY_BREAK
3602 case 97:
3603 YY_RULE_SETUP
3604 #line 850 "Scanner.ll"
3605 {
3606  if(getIsIdContext())
3607  {
3608  mIsIdAlreadyAdded = true;
3609  REJECT;
3610  }
3611  return Token::DCFANOUTLOAD;
3612  }
3613  YY_BREAK
3614 case 98:
3615 YY_RULE_SETUP
3616 #line 858 "Scanner.ll"
3617 {
3618  if(getIsIdContext())
3619  {
3620  mIsIdAlreadyAdded = true;
3621  REJECT;
3622  }
3623  return Token::DCMAXFANIN;
3624  }
3625  YY_BREAK
3626 case 99:
3627 YY_RULE_SETUP
3628 #line 866 "Scanner.ll"
3629 {
3630  if(getIsIdContext())
3631  {
3632  mIsIdAlreadyAdded = true;
3633  REJECT;
3634  }
3635  return Token::DCMAXFANOUT;
3636  }
3637  YY_BREAK
3638 case 100:
3639 YY_RULE_SETUP
3640 #line 874 "Scanner.ll"
3641 {
3642  if(getIsIdContext())
3643  {
3644  mIsIdAlreadyAdded = true;
3645  REJECT;
3646  }
3647  return Token::DELAY;
3648  }
3649  YY_BREAK
3650 case 101:
3651 YY_RULE_SETUP
3652 #line 882 "Scanner.ll"
3653 {
3654  if(getIsIdContext())
3655  {
3656  mIsIdAlreadyAdded = true;
3657  REJECT;
3658  }
3659  return Token::DELTA;
3660  }
3661  YY_BREAK
3662 case 102:
3663 YY_RULE_SETUP
3664 #line 890 "Scanner.ll"
3665 {
3666  if(getIsIdContext())
3667  {
3668  mIsIdAlreadyAdded = true;
3669  REJECT;
3670  }
3671  return Token::DERIVATION;
3672  }
3673  YY_BREAK
3674 case 103:
3675 YY_RULE_SETUP
3676 #line 898 "Scanner.ll"
3677 {
3678  if(getIsIdContext())
3679  {
3680  mIsIdAlreadyAdded = true;
3681  REJECT;
3682  }
3683  return Token::DESIGN;
3684  }
3685  YY_BREAK
3686 case 104:
3687 YY_RULE_SETUP
3688 #line 906 "Scanner.ll"
3689 {
3690  if(getIsIdContext())
3691  {
3692  mIsIdAlreadyAdded = true;
3693  REJECT;
3694  }
3695  return Token::DESIGNATOR;
3696  }
3697  YY_BREAK
3698 case 105:
3699 YY_RULE_SETUP
3700 #line 914 "Scanner.ll"
3701 {
3702  if(getIsIdContext())
3703  {
3704  mIsIdAlreadyAdded = true;
3705  REJECT;
3706  }
3707  return Token::DIFFERENCE;
3708  }
3709  YY_BREAK
3710 case 106:
3711 YY_RULE_SETUP
3712 #line 922 "Scanner.ll"
3713 {
3714  if(getIsIdContext())
3715  {
3716  mIsIdAlreadyAdded = true;
3717  REJECT;
3718  }
3719  return Token::DIRECTION;
3720  }
3721  YY_BREAK
3722 case 107:
3723 YY_RULE_SETUP
3724 #line 930 "Scanner.ll"
3725 {
3726  if(getIsIdContext())
3727  {
3728  mIsIdAlreadyAdded = true;
3729  REJECT;
3730  }
3731  return Token::DISPLAY;
3732  }
3733  YY_BREAK
3734 case 108:
3735 YY_RULE_SETUP
3736 #line 938 "Scanner.ll"
3737 {
3738  if(getIsIdContext())
3739  {
3740  mIsIdAlreadyAdded = true;
3741  REJECT;
3742  }
3743  return Token::DOMINATES;
3744  }
3745  YY_BREAK
3746 case 109:
3747 YY_RULE_SETUP
3748 #line 946 "Scanner.ll"
3749 {
3750  if(getIsIdContext())
3751  {
3752  mIsIdAlreadyAdded = true;
3753  REJECT;
3754  }
3755  return Token::DOT;
3756  }
3757  YY_BREAK
3758 case 110:
3759 YY_RULE_SETUP
3760 #line 954 "Scanner.ll"
3761 {
3762  if(getIsIdContext())
3763  {
3764  mIsIdAlreadyAdded = true;
3765  REJECT;
3766  }
3767  return Token::DURATION;
3768  }
3769  YY_BREAK
3770 case 111:
3771 YY_RULE_SETUP
3772 #line 962 "Scanner.ll"
3773 {
3774  if(getIsIdContext())
3775  {
3776  mIsIdAlreadyAdded = true;
3777  REJECT;
3778  }
3779  return Token::E;
3780  }
3781  YY_BREAK
3782 case 112:
3783 YY_RULE_SETUP
3784 #line 970 "Scanner.ll"
3785 {
3786  if(getIsIdContext())
3787  {
3788  mIsIdAlreadyAdded = true;
3789  REJECT;
3790  }
3791  return Token::EDIF;
3792  }
3793  YY_BREAK
3794 case 113:
3795 YY_RULE_SETUP
3796 #line 978 "Scanner.ll"
3797 {
3798  if(getIsIdContext())
3799  {
3800  mIsIdAlreadyAdded = true;
3801  REJECT;
3802  }
3803  return Token::EDIFLEVEL;
3804  }
3805  YY_BREAK
3806 case 114:
3807 YY_RULE_SETUP
3808 #line 986 "Scanner.ll"
3809 {
3810  if(getIsIdContext())
3811  {
3812  mIsIdAlreadyAdded = true;
3813  REJECT;
3814  }
3815  return Token::EDIFVERSION;
3816  }
3817  YY_BREAK
3818 case 115:
3819 YY_RULE_SETUP
3820 #line 994 "Scanner.ll"
3821 {
3822  if(getIsIdContext())
3823  {
3824  mIsIdAlreadyAdded = true;
3825  REJECT;
3826  }
3827  return Token::ENCLOSUREDISTANCE;
3828  }
3829  YY_BREAK
3830 case 116:
3831 YY_RULE_SETUP
3832 #line 1002 "Scanner.ll"
3833 {
3834  if(getIsIdContext())
3835  {
3836  mIsIdAlreadyAdded = true;
3837  REJECT;
3838  }
3839  return Token::ENDTYPE;
3840  }
3841  YY_BREAK
3842 case 117:
3843 YY_RULE_SETUP
3844 #line 1010 "Scanner.ll"
3845 {
3846  if(getIsIdContext())
3847  {
3848  mIsIdAlreadyAdded = true;
3849  REJECT;
3850  }
3851  return Token::ENTRY;
3852  }
3853  YY_BREAK
3854 case 118:
3855 YY_RULE_SETUP
3856 #line 1018 "Scanner.ll"
3857 {
3858  if(getIsIdContext())
3859  {
3860  mIsIdAlreadyAdded = true;
3861  REJECT;
3862  }
3863  return Token::EVENT;
3864  }
3865  YY_BREAK
3866 case 119:
3867 YY_RULE_SETUP
3868 #line 1027 "Scanner.ll"
3869 {
3870  if(getIsIdContext())
3871  {
3872  mIsIdAlreadyAdded = true;
3873  REJECT;
3874  }
3875  return Token::EXACTLY;
3876  }
3877  YY_BREAK
3878 case 120:
3879 YY_RULE_SETUP
3880 #line 1035 "Scanner.ll"
3881 {
3882  if(getIsIdContext())
3883  {
3884  mIsIdAlreadyAdded = true;
3885  REJECT;
3886  }
3887  setIsIdContext(true);
3888  return Token::EXTERNAL;
3889  }
3890  YY_BREAK
3891 case 121:
3892 YY_RULE_SETUP
3893 #line 1044 "Scanner.ll"
3894 {
3895  if(getIsIdContext())
3896  {
3897  mIsIdAlreadyAdded = true;
3898  REJECT;
3899  }
3900  return Token::FABRICATE;
3901  }
3902  YY_BREAK
3903 case 122:
3904 YY_RULE_SETUP
3905 #line 1052 "Scanner.ll"
3906 {
3907  if(getIsIdContext())
3908  {
3909  mIsIdAlreadyAdded = true;
3910  REJECT;
3911  }
3912  return Token::FALSE;
3913  }
3914  YY_BREAK
3915 case 123:
3916 YY_RULE_SETUP
3917 #line 1060 "Scanner.ll"
3918 {
3919  if(getIsIdContext())
3920  {
3921  mIsIdAlreadyAdded = true;
3922  REJECT;
3923  }
3924  return Token::FIGURE;
3925  }
3926  YY_BREAK
3927 case 124:
3928 YY_RULE_SETUP
3929 #line 1068 "Scanner.ll"
3930 {
3931  if(getIsIdContext())
3932  {
3933  mIsIdAlreadyAdded = true;
3934  REJECT;
3935  }
3936  return Token::FIGUREAREA;
3937  }
3938  YY_BREAK
3939 case 125:
3940 YY_RULE_SETUP
3941 #line 1076 "Scanner.ll"
3942 {
3943  if(getIsIdContext())
3944  {
3945  mIsIdAlreadyAdded = true;
3946  REJECT;
3947  }
3948  return Token::FIGUREGROUP;
3949  }
3950  YY_BREAK
3951 case 126:
3952 YY_RULE_SETUP
3953 #line 1084 "Scanner.ll"
3954 {
3955  if(getIsIdContext())
3956  {
3957  mIsIdAlreadyAdded = true;
3958  REJECT;
3959  }
3960  return Token::FIGUREGROUPOBJECT;
3961  }
3962  YY_BREAK
3963 case 127:
3964 YY_RULE_SETUP
3965 #line 1092 "Scanner.ll"
3966 {
3967  if(getIsIdContext())
3968  {
3969  mIsIdAlreadyAdded = true;
3970  REJECT;
3971  }
3972  return Token::FIGUREGROUPOVERRIDE;
3973  }
3974  YY_BREAK
3975 case 128:
3976 YY_RULE_SETUP
3977 #line 1100 "Scanner.ll"
3978 {
3979  if(getIsIdContext())
3980  {
3981  mIsIdAlreadyAdded = true;
3982  REJECT;
3983  }
3984  return Token::FIGUREGROUPREF;
3985  }
3986  YY_BREAK
3987 case 129:
3988 YY_RULE_SETUP
3989 #line 1108 "Scanner.ll"
3990 {
3991  if(getIsIdContext())
3992  {
3993  mIsIdAlreadyAdded = true;
3994  REJECT;
3995  }
3996  return Token::FIGUREPERIMETER;
3997  }
3998  YY_BREAK
3999 case 130:
4000 YY_RULE_SETUP
4001 #line 1116 "Scanner.ll"
4002 {
4003  if(getIsIdContext())
4004  {
4005  mIsIdAlreadyAdded = true;
4006  REJECT;
4007  }
4008  return Token::FIGUREWIDTH;
4009  }
4010  YY_BREAK
4011 case 131:
4012 YY_RULE_SETUP
4013 #line 1124 "Scanner.ll"
4014 {
4015  if(getIsIdContext())
4016  {
4017  mIsIdAlreadyAdded = true;
4018  REJECT;
4019  }
4020  return Token::FILLPATTERN;
4021  }
4022  YY_BREAK
4023 case 132:
4024 YY_RULE_SETUP
4025 #line 1132 "Scanner.ll"
4026 {
4027  if(getIsIdContext())
4028  {
4029  mIsIdAlreadyAdded = true;
4030  REJECT;
4031  }
4032  return Token::FOLLOW;
4033  }
4034  YY_BREAK
4035 case 133:
4036 YY_RULE_SETUP
4037 #line 1140 "Scanner.ll"
4038 {
4039  if(getIsIdContext())
4040  {
4041  mIsIdAlreadyAdded = true;
4042  REJECT;
4043  }
4044  return Token::FORBIDDENEVENT;
4045  }
4046  YY_BREAK
4047 case 134:
4048 YY_RULE_SETUP
4049 #line 1148 "Scanner.ll"
4050 {
4051  if(getIsIdContext())
4052  {
4053  mIsIdAlreadyAdded = true;
4054  REJECT;
4055  }
4056  return Token::GLOBALPORTREF;
4057  }
4058  YY_BREAK
4059 case 135:
4060 YY_RULE_SETUP
4061 #line 1156 "Scanner.ll"
4062 {
4063  if(getIsIdContext())
4064  {
4065  mIsIdAlreadyAdded = true;
4066  REJECT;
4067  }
4068  return Token::GREATERTHAN;
4069  }
4070  YY_BREAK
4071 case 136:
4072 YY_RULE_SETUP
4073 #line 1164 "Scanner.ll"
4074 {
4075  if(getIsIdContext())
4076  {
4077  mIsIdAlreadyAdded = true;
4078  REJECT;
4079  }
4080  return Token::GRIDMAP;
4081  }
4082  YY_BREAK
4083 case 137:
4084 YY_RULE_SETUP
4085 #line 1172 "Scanner.ll"
4086 {
4087  if(getIsIdContext())
4088  {
4089  mIsIdAlreadyAdded = true;
4090  REJECT;
4091  }
4092  return Token::IGNORE;
4093  }
4094  YY_BREAK
4095 case 138:
4096 YY_RULE_SETUP
4097 #line 1180 "Scanner.ll"
4098 {
4099  if(getIsIdContext())
4100  {
4101  mIsIdAlreadyAdded = true;
4102  REJECT;
4103  }
4104  return Token::INCLUDEFIGUREGROUP;
4105  }
4106  YY_BREAK
4107 case 139:
4108 YY_RULE_SETUP
4109 #line 1188 "Scanner.ll"
4110 {
4111  if(getIsIdContext())
4112  {
4113  mIsIdAlreadyAdded = true;
4114  REJECT;
4115  }
4116  return Token::INITIAL_KW;
4117  }
4118  YY_BREAK
4119 case 140:
4120 YY_RULE_SETUP
4121 #line 1196 "Scanner.ll"
4122 {
4123  if(getIsIdContext())
4124  {
4125  mIsIdAlreadyAdded = true;
4126  REJECT;
4127  }
4128  setIsIdContext(true);
4129  return Token::INSTANCE;
4130  }
4131  YY_BREAK
4132 case 141:
4133 YY_RULE_SETUP
4134 #line 1205 "Scanner.ll"
4135 {
4136  if(getIsIdContext())
4137  {
4138  mIsIdAlreadyAdded = true;
4139  REJECT;
4140  }
4141  return Token::INSTANCEBACKANNOTATE;
4142  }
4143  YY_BREAK
4144 case 142:
4145 YY_RULE_SETUP
4146 #line 1213 "Scanner.ll"
4147 {
4148  if(getIsIdContext())
4149  {
4150  mIsIdAlreadyAdded = true;
4151  REJECT;
4152  }
4153  return Token::INSTANCEGROUP;
4154  }
4155  YY_BREAK
4156 case 143:
4157 YY_RULE_SETUP
4158 #line 1221 "Scanner.ll"
4159 {
4160  if(getIsIdContext())
4161  {
4162  mIsIdAlreadyAdded = true;
4163  REJECT;
4164  }
4165  return Token::INSTANCEMAP;
4166  }
4167  YY_BREAK
4168 case 144:
4169 YY_RULE_SETUP
4170 #line 1229 "Scanner.ll"
4171 {
4172  if(getIsIdContext())
4173  {
4174  mIsIdAlreadyAdded = true;
4175  REJECT;
4176  }
4177  setIsIdContext(true);
4178  return Token::INSTANCEREF;
4179  }
4180  YY_BREAK
4181 case 145:
4182 YY_RULE_SETUP
4183 #line 1238 "Scanner.ll"
4184 {
4185  if(getIsIdContext())
4186  {
4187  mIsIdAlreadyAdded = true;
4188  REJECT;
4189  }
4190  return Token::INTEGER;
4191  }
4192  YY_BREAK
4193 case 146:
4194 YY_RULE_SETUP
4195 #line 1246 "Scanner.ll"
4196 {
4197  if(getIsIdContext())
4198  {
4199  mIsIdAlreadyAdded = true;
4200  REJECT;
4201  }
4202  return Token::INTEGERDISPLAY;
4203  }
4204  YY_BREAK
4205 case 147:
4206 YY_RULE_SETUP
4207 #line 1254 "Scanner.ll"
4208 {
4209  if(getIsIdContext())
4210  {
4211  mIsIdAlreadyAdded = true;
4212  REJECT;
4213  }
4214  return Token::INTERFACE;
4215  }
4216  YY_BREAK
4217 case 148:
4218 YY_RULE_SETUP
4219 #line 1262 "Scanner.ll"
4220 {
4221  if(getIsIdContext())
4222  {
4223  mIsIdAlreadyAdded = true;
4224  REJECT;
4225  }
4226  return Token::INTERFIGUREGROUPSPACING;
4227  }
4228  YY_BREAK
4229 case 149:
4230 YY_RULE_SETUP
4231 #line 1270 "Scanner.ll"
4232 {
4233  if(getIsIdContext())
4234  {
4235  mIsIdAlreadyAdded = true;
4236  REJECT;
4237  }
4238  return Token::INTERSECTION;
4239  }
4240  YY_BREAK
4241 case 150:
4242 YY_RULE_SETUP
4243 #line 1278 "Scanner.ll"
4244 {
4245  if(getIsIdContext())
4246  {
4247  mIsIdAlreadyAdded = true;
4248  REJECT;
4249  }
4250  return Token::INTRAFIGUREGROUPSPACING;
4251  }
4252  YY_BREAK
4253 case 151:
4254 YY_RULE_SETUP
4255 #line 1286 "Scanner.ll"
4256 {
4257  if(getIsIdContext())
4258  {
4259  mIsIdAlreadyAdded = true;
4260  REJECT;
4261  }
4262  return Token::INVERSE;
4263  }
4264  YY_BREAK
4265 case 152:
4266 YY_RULE_SETUP
4267 #line 1294 "Scanner.ll"
4268 {
4269  if(getIsIdContext())
4270  {
4271  mIsIdAlreadyAdded = true;
4272  REJECT;
4273  }
4274  return Token::ISOLATED;
4275  }
4276  YY_BREAK
4277 case 153:
4278 YY_RULE_SETUP
4279 #line 1302 "Scanner.ll"
4280 {
4281  if(getIsIdContext())
4282  {
4283  mIsIdAlreadyAdded = true;
4284  REJECT;
4285  }
4286  return Token::JOINED;
4287  }
4288  YY_BREAK
4289 case 154:
4290 YY_RULE_SETUP
4291 #line 1310 "Scanner.ll"
4292 {
4293  if(getIsIdContext())
4294  {
4295  mIsIdAlreadyAdded = true;
4296  REJECT;
4297  }
4298  return Token::JUSTIFY;
4299  }
4300  YY_BREAK
4301 case 155:
4302 YY_RULE_SETUP
4303 #line 1318 "Scanner.ll"
4304 {
4305  if(getIsIdContext())
4306  {
4307  mIsIdAlreadyAdded = true;
4308  REJECT;
4309  }
4310  setIsIdContext(true);
4311  return Token::KEYWORDDISPLAY;
4312  }
4313  YY_BREAK
4314 case 156:
4315 YY_RULE_SETUP
4316 #line 1327 "Scanner.ll"
4317 {
4318  if(getIsIdContext())
4319  {
4320  mIsIdAlreadyAdded = true;
4321  REJECT;
4322  }
4323  return Token::KEYWORDLEVEL;
4324  }
4325  YY_BREAK
4326 case 157:
4327 YY_RULE_SETUP
4328 #line 1335 "Scanner.ll"
4329 {
4330  if(getIsIdContext())
4331  {
4332  mIsIdAlreadyAdded = true;
4333  REJECT;
4334  }
4335  return Token::KEYWORDMAP;
4336  }
4337  YY_BREAK
4338 case 158:
4339 YY_RULE_SETUP
4340 #line 1343 "Scanner.ll"
4341 {
4342  if(getIsIdContext())
4343  {
4344  mIsIdAlreadyAdded = true;
4345  REJECT;
4346  }
4347  return Token::LESSTHAN;
4348  }
4349  YY_BREAK
4350 case 159:
4351 YY_RULE_SETUP
4352 #line 1351 "Scanner.ll"
4353 {
4354  if(getIsIdContext())
4355  {
4356  mIsIdAlreadyAdded = true;
4357  REJECT;
4358  }
4359  setIsIdContext(true);
4360  return Token::LIBRARY;
4361  }
4362  YY_BREAK
4363 case 160:
4364 YY_RULE_SETUP
4365 #line 1360 "Scanner.ll"
4366 {
4367  if(getIsIdContext())
4368  {
4369  mIsIdAlreadyAdded = true;
4370  REJECT;
4371  }
4372  setIsIdContext(true);
4373  return Token::LIBRARYREF;
4374  }
4375  YY_BREAK
4376 case 161:
4377 YY_RULE_SETUP
4378 #line 1369 "Scanner.ll"
4379 {
4380  if(getIsIdContext())
4381  {
4382  mIsIdAlreadyAdded = true;
4383  REJECT;
4384  }
4385  return Token::LISTOFNETS;
4386  }
4387  YY_BREAK
4388 case 162:
4389 YY_RULE_SETUP
4390 #line 1377 "Scanner.ll"
4391 {
4392  if(getIsIdContext())
4393  {
4394  mIsIdAlreadyAdded = true;
4395  REJECT;
4396  }
4397  return Token::LISTOFPORTS;
4398  }
4399  YY_BREAK
4400 case 163:
4401 YY_RULE_SETUP
4402 #line 1385 "Scanner.ll"
4403 {
4404  if(getIsIdContext())
4405  {
4406  mIsIdAlreadyAdded = true;
4407  REJECT;
4408  }
4409  return Token::LOADDELAY;
4410  }
4411  YY_BREAK
4412 case 164:
4413 YY_RULE_SETUP
4414 #line 1393 "Scanner.ll"
4415 {
4416  if(getIsIdContext())
4417  {
4418  mIsIdAlreadyAdded = true;
4419  REJECT;
4420  }
4421  return Token::LOGICASSIGN;
4422  }
4423  YY_BREAK
4424 case 165:
4425 YY_RULE_SETUP
4426 #line 1401 "Scanner.ll"
4427 {
4428  if(getIsIdContext())
4429  {
4430  mIsIdAlreadyAdded = true;
4431  REJECT;
4432  }
4433  setIsIdContext(true);
4434  return Token::LOGICINPUT;
4435  }
4436  YY_BREAK
4437 case 166:
4438 YY_RULE_SETUP
4439 #line 1410 "Scanner.ll"
4440 {
4441  if(getIsIdContext())
4442  {
4443  mIsIdAlreadyAdded = true;
4444  REJECT;
4445  }
4446  return Token::LOGICLIST;
4447  }
4448  YY_BREAK
4449 case 167:
4450 YY_RULE_SETUP
4451 #line 1418 "Scanner.ll"
4452 {
4453  if(getIsIdContext())
4454  {
4455  mIsIdAlreadyAdded = true;
4456  REJECT;
4457  }
4458  return Token::LOGICMAPINPUT;
4459  }
4460  YY_BREAK
4461 case 168:
4462 YY_RULE_SETUP
4463 #line 1426 "Scanner.ll"
4464 {
4465  if(getIsIdContext())
4466  {
4467  mIsIdAlreadyAdded = true;
4468  REJECT;
4469  }
4470  return Token::LOGICMAPOUTPUT;
4471  }
4472  YY_BREAK
4473 case 169:
4474 YY_RULE_SETUP
4475 #line 1434 "Scanner.ll"
4476 {
4477  if(getIsIdContext())
4478  {
4479  mIsIdAlreadyAdded = true;
4480  REJECT;
4481  }
4482  return Token::LOGICONEOF;
4483  }
4484  YY_BREAK
4485 case 170:
4486 YY_RULE_SETUP
4487 #line 1442 "Scanner.ll"
4488 {
4489  if(getIsIdContext())
4490  {
4491  mIsIdAlreadyAdded = true;
4492  REJECT;
4493  }
4494  setIsIdContext(true);
4495  return Token::LOGICOUTPUT;
4496  }
4497  YY_BREAK
4498 case 171:
4499 YY_RULE_SETUP
4500 #line 1451 "Scanner.ll"
4501 {
4502  if(getIsIdContext())
4503  {
4504  mIsIdAlreadyAdded = true;
4505  REJECT;
4506  }
4507  return Token::LOGICPORT;
4508  }
4509  YY_BREAK
4510 case 172:
4511 YY_RULE_SETUP
4512 #line 1459 "Scanner.ll"
4513 {
4514  if(getIsIdContext())
4515  {
4516  mIsIdAlreadyAdded = true;
4517  REJECT;
4518  }
4519  return Token::LOGICREF;
4520  }
4521  YY_BREAK
4522 case 173:
4523 YY_RULE_SETUP
4524 #line 1467 "Scanner.ll"
4525 {
4526  if(getIsIdContext())
4527  {
4528  mIsIdAlreadyAdded = true;
4529  REJECT;
4530  }
4531  setIsIdContext(true);
4532  return Token::LOGICVALUE;
4533  }
4534  YY_BREAK
4535 case 174:
4536 YY_RULE_SETUP
4537 #line 1476 "Scanner.ll"
4538 {
4539  if(getIsIdContext())
4540  {
4541  mIsIdAlreadyAdded = true;
4542  REJECT;
4543  }
4544  return Token::LOGICWAVEFORM;
4545  }
4546  YY_BREAK
4547 case 175:
4548 YY_RULE_SETUP
4549 #line 1484 "Scanner.ll"
4550 {
4551  if(getIsIdContext())
4552  {
4553  mIsIdAlreadyAdded = true;
4554  REJECT;
4555  }
4556  return Token::MAINTAIN;
4557  }
4558  YY_BREAK
4559 case 176:
4560 YY_RULE_SETUP
4561 #line 1492 "Scanner.ll"
4562 {
4563  if(getIsIdContext())
4564  {
4565  mIsIdAlreadyAdded = true;
4566  REJECT;
4567  }
4568  return Token::MATCH;
4569  }
4570  YY_BREAK
4571 case 177:
4572 YY_RULE_SETUP
4573 #line 1500 "Scanner.ll"
4574 {
4575  if(getIsIdContext())
4576  {
4577  mIsIdAlreadyAdded = true;
4578  REJECT;
4579  }
4580  setIsIdContext(true);
4581  return Token::MEMBER;
4582  }
4583  YY_BREAK
4584 case 178:
4585 YY_RULE_SETUP
4586 #line 1509 "Scanner.ll"
4587 {
4588  if(getIsIdContext())
4589  {
4590  mIsIdAlreadyAdded = true;
4591  REJECT;
4592  }
4593  return Token::MINOMAX;
4594  }
4595  YY_BREAK
4596 case 179:
4597 YY_RULE_SETUP
4598 #line 1517 "Scanner.ll"
4599 {
4600  if(getIsIdContext())
4601  {
4602  mIsIdAlreadyAdded = true;
4603  REJECT;
4604  }
4605  return Token::MINOMAXDISPLAY;
4606  }
4607  YY_BREAK
4608 case 180:
4609 YY_RULE_SETUP
4610 #line 1525 "Scanner.ll"
4611 {
4612  if(getIsIdContext())
4613  {
4614  mIsIdAlreadyAdded = true;
4615  REJECT;
4616  }
4617  return Token::MNM;
4618  }
4619  YY_BREAK
4620 case 181:
4621 YY_RULE_SETUP
4622 #line 1533 "Scanner.ll"
4623 {
4624  if(getIsIdContext())
4625  {
4626  mIsIdAlreadyAdded = true;
4627  REJECT;
4628  }
4629  return Token::MULTIPLEVALUESET;
4630  }
4631  YY_BREAK
4632 case 182:
4633 YY_RULE_SETUP
4634 #line 1541 "Scanner.ll"
4635 {
4636  if(getIsIdContext())
4637  {
4638  mIsIdAlreadyAdded = true;
4639  REJECT;
4640  }
4641  return Token::MUSTJOIN;
4642  }
4643  YY_BREAK
4644 case 183:
4645 YY_RULE_SETUP
4646 #line 1549 "Scanner.ll"
4647 {
4648  if(getIsIdContext())
4649  {
4650  mIsIdAlreadyAdded = true;
4651  REJECT;
4652  }
4653  setIsIdContext(true);
4654  return Token::NAME;
4655  }
4656  YY_BREAK
4657 case 184:
4658 YY_RULE_SETUP
4659 #line 1558 "Scanner.ll"
4660 {
4661  if(getIsIdContext())
4662  {
4663  mIsIdAlreadyAdded = true;
4664  REJECT;
4665  }
4666  setIsIdContext(true);
4667  return Token::NET;
4668  }
4669  YY_BREAK
4670 case 185:
4671 YY_RULE_SETUP
4672 #line 1567 "Scanner.ll"
4673 {
4674  if(getIsIdContext())
4675  {
4676  mIsIdAlreadyAdded = true;
4677  REJECT;
4678  }
4679  return Token::NETBACKANNOTATE;
4680  }
4681  YY_BREAK
4682 case 186:
4683 YY_RULE_SETUP
4684 #line 1575 "Scanner.ll"
4685 {
4686  if(getIsIdContext())
4687  {
4688  mIsIdAlreadyAdded = true;
4689  REJECT;
4690  }
4691  setIsIdContext(true);
4692  return Token::NETBUNDLE;
4693  }
4694  YY_BREAK
4695 case 187:
4696 YY_RULE_SETUP
4697 #line 1584 "Scanner.ll"
4698 {
4699  if(getIsIdContext())
4700  {
4701  mIsIdAlreadyAdded = true;
4702  REJECT;
4703  }
4704  return Token::NETDELAY;
4705  }
4706  YY_BREAK
4707 case 188:
4708 YY_RULE_SETUP
4709 #line 1592 "Scanner.ll"
4710 {
4711  if(getIsIdContext())
4712  {
4713  mIsIdAlreadyAdded = true;
4714  REJECT;
4715  }
4716  return Token::NETGROUP;
4717  }
4718  YY_BREAK
4719 case 189:
4720 YY_RULE_SETUP
4721 #line 1600 "Scanner.ll"
4722 {
4723  if(getIsIdContext())
4724  {
4725  mIsIdAlreadyAdded = true;
4726  REJECT;
4727  }
4728  return Token::NETMAP;
4729  }
4730  YY_BREAK
4731 case 190:
4732 YY_RULE_SETUP
4733 #line 1608 "Scanner.ll"
4734 {
4735  if(getIsIdContext())
4736  {
4737  mIsIdAlreadyAdded = true;
4738  REJECT;
4739  }
4740  setIsIdContext(true);
4741  return Token::NETREF;
4742  }
4743  YY_BREAK
4744 case 191:
4745 YY_RULE_SETUP
4746 #line 1617 "Scanner.ll"
4747 {
4748  if(getIsIdContext())
4749  {
4750  mIsIdAlreadyAdded = true;
4751  REJECT;
4752  }
4753  return Token::NOCHANGE;
4754  }
4755  YY_BREAK
4756 case 192:
4757 YY_RULE_SETUP
4758 #line 1625 "Scanner.ll"
4759 {
4760  if(getIsIdContext())
4761  {
4762  mIsIdAlreadyAdded = true;
4763  REJECT;
4764  }
4765  return Token::NONPERMUTABLE;
4766  }
4767  YY_BREAK
4768 case 193:
4769 YY_RULE_SETUP
4770 #line 1633 "Scanner.ll"
4771 {
4772  if(getIsIdContext())
4773  {
4774  mIsIdAlreadyAdded = true;
4775  REJECT;
4776  }
4777  return Token::NOTALLOWED;
4778  }
4779  YY_BREAK
4780 case 194:
4781 YY_RULE_SETUP
4782 #line 1641 "Scanner.ll"
4783 {
4784  if(getIsIdContext())
4785  {
4786  mIsIdAlreadyAdded = true;
4787  REJECT;
4788  }
4789  return Token::NOTCHSPACING;
4790  }
4791  YY_BREAK
4792 case 195:
4793 YY_RULE_SETUP
4794 #line 1649 "Scanner.ll"
4795 {
4796  if(getIsIdContext())
4797  {
4798  mIsIdAlreadyAdded = true;
4799  REJECT;
4800  }
4801  return Token::NUMBER;
4802  }
4803  YY_BREAK
4804 case 196:
4805 YY_RULE_SETUP
4806 #line 1657 "Scanner.ll"
4807 {
4808  if(getIsIdContext())
4809  {
4810  mIsIdAlreadyAdded = true;
4811  REJECT;
4812  }
4813  return Token::NUMBERDEFINITION;
4814  }
4815  YY_BREAK
4816 case 197:
4817 YY_RULE_SETUP
4818 #line 1665 "Scanner.ll"
4819 {
4820  if(getIsIdContext())
4821  {
4822  mIsIdAlreadyAdded = true;
4823  REJECT;
4824  }
4825  return Token::NUMBERDISPLAY;
4826  }
4827  YY_BREAK
4828 case 198:
4829 YY_RULE_SETUP
4830 #line 1673 "Scanner.ll"
4831 {
4832  if(getIsIdContext())
4833  {
4834  mIsIdAlreadyAdded = true;
4835  REJECT;
4836  }
4837  return Token::OFFPAGECONNECTOR;
4838  }
4839  YY_BREAK
4840 case 199:
4841 YY_RULE_SETUP
4842 #line 1681 "Scanner.ll"
4843 {
4844  if(getIsIdContext())
4845  {
4846  mIsIdAlreadyAdded = true;
4847  REJECT;
4848  }
4849  return Token::OFFSETEVENT;
4850  }
4851  YY_BREAK
4852 case 200:
4853 YY_RULE_SETUP
4854 #line 1689 "Scanner.ll"
4855 {
4856  if(getIsIdContext())
4857  {
4858  mIsIdAlreadyAdded = true;
4859  REJECT;
4860  }
4861  return Token::OPENSHAPE;
4862  }
4863  YY_BREAK
4864 case 201:
4865 YY_RULE_SETUP
4866 #line 1697 "Scanner.ll"
4867 {
4868  if(getIsIdContext())
4869  {
4870  mIsIdAlreadyAdded = true;
4871  REJECT;
4872  }
4873  return Token::ORIENTATION;
4874  }
4875  YY_BREAK
4876 case 202:
4877 YY_RULE_SETUP
4878 #line 1705 "Scanner.ll"
4879 {
4880  if(getIsIdContext())
4881  {
4882  mIsIdAlreadyAdded = true;
4883  REJECT;
4884  }
4885  return Token::ORIGIN;
4886  }
4887  YY_BREAK
4888 case 203:
4889 YY_RULE_SETUP
4890 #line 1713 "Scanner.ll"
4891 {
4892  if(getIsIdContext())
4893  {
4894  mIsIdAlreadyAdded = true;
4895  REJECT;
4896  }
4897  return Token::OVERHANGDISTANCE;
4898  }
4899  YY_BREAK
4900 case 204:
4901 YY_RULE_SETUP
4902 #line 1721 "Scanner.ll"
4903 {
4904  if(getIsIdContext())
4905  {
4906  mIsIdAlreadyAdded = true;
4907  REJECT;
4908  }
4909  return Token::OVERLAPDISTANCE;
4910  }
4911  YY_BREAK
4912 case 205:
4913 YY_RULE_SETUP
4914 #line 1729 "Scanner.ll"
4915 {
4916  if(getIsIdContext())
4917  {
4918  mIsIdAlreadyAdded = true;
4919  REJECT;
4920  }
4921  return Token::OVERSIZE;
4922  }
4923  YY_BREAK
4924 case 206:
4925 YY_RULE_SETUP
4926 #line 1737 "Scanner.ll"
4927 {
4928  if(getIsIdContext())
4929  {
4930  mIsIdAlreadyAdded = true;
4931  REJECT;
4932  }
4933  return Token::OWNER;
4934  }
4935  YY_BREAK
4936 case 207:
4937 YY_RULE_SETUP
4938 #line 1745 "Scanner.ll"
4939 {
4940  if(getIsIdContext())
4941  {
4942  mIsIdAlreadyAdded = true;
4943  REJECT;
4944  }
4945  return Token::PAGE;
4946  }
4947  YY_BREAK
4948 case 208:
4949 YY_RULE_SETUP
4950 #line 1753 "Scanner.ll"
4951 {
4952  if(getIsIdContext())
4953  {
4954  mIsIdAlreadyAdded = true;
4955  REJECT;
4956  }
4957  return Token::PAGESIZE_EDIF;
4958  }
4959  YY_BREAK
4960 case 209:
4961 YY_RULE_SETUP
4962 #line 1761 "Scanner.ll"
4963 {
4964  if(getIsIdContext())
4965  {
4966  mIsIdAlreadyAdded = true;
4967  REJECT;
4968  }
4969  setIsIdContext(true);
4970  return Token::PARAMETER;
4971  }
4972  YY_BREAK
4973 case 210:
4974 YY_RULE_SETUP
4975 #line 1770 "Scanner.ll"
4976 {
4977  if(getIsIdContext())
4978  {
4979  mIsIdAlreadyAdded = true;
4980  REJECT;
4981  }
4982  setIsIdContext(true);
4983  return Token::PARAMETERASSIGN;
4984  }
4985  YY_BREAK
4986 case 211:
4987 YY_RULE_SETUP
4988 #line 1779 "Scanner.ll"
4989 {
4990  if(getIsIdContext())
4991  {
4992  mIsIdAlreadyAdded = true;
4993  REJECT;
4994  }
4995  return Token::PARAMETERDISPLAY;
4996  }
4997  YY_BREAK
4998 case 212:
4999 YY_RULE_SETUP
5000 #line 1787 "Scanner.ll"
5001 {
5002  if(getIsIdContext())
5003  {
5004  mIsIdAlreadyAdded = true;
5005  REJECT;
5006  }
5007  return Token::PATH;
5008  }
5009  YY_BREAK
5010 case 213:
5011 YY_RULE_SETUP
5012 #line 1795 "Scanner.ll"
5013 {
5014  if(getIsIdContext())
5015  {
5016  mIsIdAlreadyAdded = true;
5017  REJECT;
5018  }
5019  return Token::PATHDELAY;
5020  }
5021  YY_BREAK
5022 case 214:
5023 YY_RULE_SETUP
5024 #line 1803 "Scanner.ll"
5025 {
5026  if(getIsIdContext())
5027  {
5028  mIsIdAlreadyAdded = true;
5029  REJECT;
5030  }
5031  return Token::PATHWIDTH;
5032  }
5033  YY_BREAK
5034 case 215:
5035 YY_RULE_SETUP
5036 #line 1811 "Scanner.ll"
5037 {
5038  if(getIsIdContext())
5039  {
5040  mIsIdAlreadyAdded = true;
5041  REJECT;
5042  }
5043  return Token::PERMUTABLE;
5044  }
5045  YY_BREAK
5046 case 216:
5047 YY_RULE_SETUP
5048 #line 1819 "Scanner.ll"
5049 {
5050  if(getIsIdContext())
5051  {
5052  mIsIdAlreadyAdded = true;
5053  REJECT;
5054  }
5055  return Token::PHYSICALDESIGNRULE;
5056  }
5057  YY_BREAK
5058 case 217:
5059 YY_RULE_SETUP
5060 #line 1827 "Scanner.ll"
5061 {
5062  if(getIsIdContext())
5063  {
5064  mIsIdAlreadyAdded = true;
5065  REJECT;
5066  }
5067  return Token::PLUG;
5068  }
5069  YY_BREAK
5070 case 218:
5071 YY_RULE_SETUP
5072 #line 1835 "Scanner.ll"
5073 {
5074  if(getIsIdContext())
5075  {
5076  mIsIdAlreadyAdded = true;
5077  REJECT;
5078  }
5079  return Token::POINT;
5080  }
5081  YY_BREAK
5082 case 219:
5083 YY_RULE_SETUP
5084 #line 1843 "Scanner.ll"
5085 {
5086  if(getIsIdContext())
5087  {
5088  mIsIdAlreadyAdded = true;
5089  REJECT;
5090  }
5091  return Token::POINTDISPLAY;
5092  }
5093  YY_BREAK
5094 case 220:
5095 YY_RULE_SETUP
5096 #line 1851 "Scanner.ll"
5097 {
5098  if(getIsIdContext())
5099  {
5100  mIsIdAlreadyAdded = true;
5101  REJECT;
5102  }
5103  return Token::POINTLIST;
5104  }
5105  YY_BREAK
5106 case 221:
5107 YY_RULE_SETUP
5108 #line 1859 "Scanner.ll"
5109 {
5110  if(getIsIdContext())
5111  {
5112  mIsIdAlreadyAdded = true;
5113  REJECT;
5114  }
5115  return Token::POLYGON;
5116  }
5117  YY_BREAK
5118 case 222:
5119 YY_RULE_SETUP
5120 #line 1867 "Scanner.ll"
5121 {
5122  if(getIsIdContext())
5123  {
5124  mIsIdAlreadyAdded = true;
5125  REJECT;
5126  }
5127  setIsIdContext(true);
5128  return Token::PORT;
5129  }
5130  YY_BREAK
5131 case 223:
5132 YY_RULE_SETUP
5133 #line 1876 "Scanner.ll"
5134 {
5135  if(getIsIdContext())
5136  {
5137  mIsIdAlreadyAdded = true;
5138  REJECT;
5139  }
5140  return Token::PORTBACKANNOTATE;
5141  }
5142  YY_BREAK
5143 case 224:
5144 YY_RULE_SETUP
5145 #line 1884 "Scanner.ll"
5146 {
5147  if(getIsIdContext())
5148  {
5149  mIsIdAlreadyAdded = true;
5150  REJECT;
5151  }
5152  setIsIdContext(true);
5153  return Token::PORTBUNDLE;
5154  }
5155  YY_BREAK
5156 case 225:
5157 YY_RULE_SETUP
5158 #line 1893 "Scanner.ll"
5159 {
5160  if(getIsIdContext())
5161  {
5162  mIsIdAlreadyAdded = true;
5163  REJECT;
5164  }
5165  return Token::PORTDELAY;
5166  }
5167  YY_BREAK
5168 case 226:
5169 YY_RULE_SETUP
5170 #line 1901 "Scanner.ll"
5171 {
5172  if(getIsIdContext())
5173  {
5174  mIsIdAlreadyAdded = true;
5175  REJECT;
5176  }
5177  return Token::PORTGROUP;
5178  }
5179  YY_BREAK
5180 case 227:
5181 YY_RULE_SETUP
5182 #line 1909 "Scanner.ll"
5183 {
5184  if(getIsIdContext())
5185  {
5186  mIsIdAlreadyAdded = true;
5187  REJECT;
5188  }
5189  return Token::PORTIMPLEMENTATION;
5190  }
5191  YY_BREAK
5192 case 228:
5193 YY_RULE_SETUP
5194 #line 1917 "Scanner.ll"
5195 {
5196  if(getIsIdContext())
5197  {
5198  mIsIdAlreadyAdded = true;
5199  REJECT;
5200  }
5201  return Token::PORTINSTANCE;
5202  }
5203  YY_BREAK
5204 case 229:
5205 YY_RULE_SETUP
5206 #line 1925 "Scanner.ll"
5207 {
5208  if(getIsIdContext())
5209  {
5210  mIsIdAlreadyAdded = true;
5211  REJECT;
5212  }
5213  setIsIdContext(true);
5214  return Token::PORTLIST;
5215  }
5216  YY_BREAK
5217 case 230:
5218 YY_RULE_SETUP
5219 #line 1934 "Scanner.ll"
5220 {
5221  if(getIsIdContext())
5222  {
5223  mIsIdAlreadyAdded = true;
5224  REJECT;
5225  }
5226  setIsIdContext(true);
5227  return Token::PORTLISTALIAS;
5228  }
5229  YY_BREAK
5230 case 231:
5231 YY_RULE_SETUP
5232 #line 1943 "Scanner.ll"
5233 {
5234  if(getIsIdContext())
5235  {
5236  mIsIdAlreadyAdded = true;
5237  REJECT;
5238  }
5239  return Token::PORTMAP;
5240  }
5241  YY_BREAK
5242 case 232:
5243 YY_RULE_SETUP
5244 #line 1951 "Scanner.ll"
5245 {
5246  if(getIsIdContext())
5247  {
5248  mIsIdAlreadyAdded = true;
5249  REJECT;
5250  }
5251  setIsIdContext(true);
5252  return Token::PORTREF;
5253  }
5254  YY_BREAK
5255 case 233:
5256 YY_RULE_SETUP
5257 #line 1960 "Scanner.ll"
5258 {
5259  if(getIsIdContext())
5260  {
5261  mIsIdAlreadyAdded = true;
5262  REJECT;
5263  }
5264  return Token::PROGRAM;
5265  }
5266  YY_BREAK
5267 case 234:
5268 YY_RULE_SETUP
5269 #line 1968 "Scanner.ll"
5270 {
5271  if(getIsIdContext())
5272  {
5273  mIsIdAlreadyAdded = true;
5274  REJECT;
5275  }
5276  setIsIdContext(true);
5277  return Token::PROPERTY;
5278  }
5279  YY_BREAK
5280 case 235:
5281 YY_RULE_SETUP
5282 #line 1977 "Scanner.ll"
5283 {
5284  if(getIsIdContext())
5285  {
5286  mIsIdAlreadyAdded = true;
5287  REJECT;
5288  }
5289  return Token::PROPERTYDISPLAY;
5290  }
5291  YY_BREAK
5292 case 236:
5293 YY_RULE_SETUP
5294 #line 1985 "Scanner.ll"
5295 {
5296  if(getIsIdContext())
5297  {
5298  mIsIdAlreadyAdded = true;
5299  REJECT;
5300  }
5301  return Token::PROTECTIONFRAME;
5302  }
5303  YY_BREAK
5304 case 237:
5305 YY_RULE_SETUP
5306 #line 1993 "Scanner.ll"
5307 {
5308  if(getIsIdContext())
5309  {
5310  mIsIdAlreadyAdded = true;
5311  REJECT;
5312  }
5313  return Token::PT;
5314  }
5315  YY_BREAK
5316 case 238:
5317 YY_RULE_SETUP
5318 #line 2001 "Scanner.ll"
5319 {
5320  if(getIsIdContext())
5321  {
5322  mIsIdAlreadyAdded = true;
5323  REJECT;
5324  }
5325  return Token::RANGEVECTOR;
5326  }
5327  YY_BREAK
5328 case 239:
5329 YY_RULE_SETUP
5330 #line 2009 "Scanner.ll"
5331 {
5332  if(getIsIdContext())
5333  {
5334  mIsIdAlreadyAdded = true;
5335  REJECT;
5336  }
5337  return Token::RECTANGLE;
5338  }
5339  YY_BREAK
5340 case 240:
5341 YY_RULE_SETUP
5342 #line 2017 "Scanner.ll"
5343 {
5344  if(getIsIdContext())
5345  {
5346  mIsIdAlreadyAdded = true;
5347  REJECT;
5348  }
5349  return Token::RECTANGLESIZE;
5350  }
5351  YY_BREAK
5352 case 241:
5353 YY_RULE_SETUP
5354 #line 2025 "Scanner.ll"
5355 {
5356  if(getIsIdContext())
5357  {
5358  mIsIdAlreadyAdded = true;
5359  REJECT;
5360  }
5361  setIsIdContext(true);
5362  return Token::RENAME;
5363  }
5364  YY_BREAK
5365 case 242:
5366 YY_RULE_SETUP
5367 #line 2034 "Scanner.ll"
5368 {
5369  if(getIsIdContext())
5370  {
5371  mIsIdAlreadyAdded = true;
5372  REJECT;
5373  }
5374  return Token::RESOLVES;
5375  }
5376  YY_BREAK
5377 case 243:
5378 YY_RULE_SETUP
5379 #line 2042 "Scanner.ll"
5380 {
5381  if(getIsIdContext())
5382  {
5383  mIsIdAlreadyAdded = true;
5384  REJECT;
5385  }
5386  return Token::SCALE;
5387  }
5388  YY_BREAK
5389 case 244:
5390 YY_RULE_SETUP
5391 #line 2050 "Scanner.ll"
5392 {
5393  if(getIsIdContext())
5394  {
5395  mIsIdAlreadyAdded = true;
5396  REJECT;
5397  }
5398  return Token::SCALEX;
5399  }
5400  YY_BREAK
5401 case 245:
5402 YY_RULE_SETUP
5403 #line 2058 "Scanner.ll"
5404 {
5405  if(getIsIdContext())
5406  {
5407  mIsIdAlreadyAdded = true;
5408  REJECT;
5409  }
5410  return Token::SCALEY;
5411  }
5412  YY_BREAK
5413 case 246:
5414 YY_RULE_SETUP
5415 #line 2066 "Scanner.ll"
5416 {
5417  if(getIsIdContext())
5418  {
5419  mIsIdAlreadyAdded = true;
5420  REJECT;
5421  }
5422  return Token::SECTION;
5423  }
5424  YY_BREAK
5425 case 247:
5426 YY_RULE_SETUP
5427 #line 2074 "Scanner.ll"
5428 {
5429  if(getIsIdContext())
5430  {
5431  mIsIdAlreadyAdded = true;
5432  REJECT;
5433  }
5434  return Token::SHAPE;
5435  }
5436  YY_BREAK
5437 case 248:
5438 YY_RULE_SETUP
5439 #line 2082 "Scanner.ll"
5440 {
5441  if(getIsIdContext())
5442  {
5443  mIsIdAlreadyAdded = true;
5444  REJECT;
5445  }
5446  setIsIdContext(true);
5447  return Token::SIMULATE;
5448  }
5449  YY_BREAK
5450 case 249:
5451 YY_RULE_SETUP
5452 #line 2091 "Scanner.ll"
5453 {
5454  if(getIsIdContext())
5455  {
5456  mIsIdAlreadyAdded = true;
5457  REJECT;
5458  }
5459  return Token::SIMULATIONINFO;
5460  }
5461  YY_BREAK
5462 case 250:
5463 YY_RULE_SETUP
5464 #line 2099 "Scanner.ll"
5465 {
5466  if(getIsIdContext())
5467  {
5468  mIsIdAlreadyAdded = true;
5469  REJECT;
5470  }
5471  return Token::SINGLEVALUESET;
5472  }
5473  YY_BREAK
5474 case 251:
5475 YY_RULE_SETUP
5476 #line 2107 "Scanner.ll"
5477 {
5478  if(getIsIdContext())
5479  {
5480  mIsIdAlreadyAdded = true;
5481  REJECT;
5482  }
5483  return Token::SITE;
5484  }
5485  YY_BREAK
5486 case 252:
5487 YY_RULE_SETUP
5488 #line 2115 "Scanner.ll"
5489 {
5490  if(getIsIdContext())
5491  {
5492  mIsIdAlreadyAdded = true;
5493  REJECT;
5494  }
5495  return Token::SOCKET;
5496  }
5497  YY_BREAK
5498 case 253:
5499 YY_RULE_SETUP
5500 #line 2123 "Scanner.ll"
5501 {
5502  if(getIsIdContext())
5503  {
5504  mIsIdAlreadyAdded = true;
5505  REJECT;
5506  }
5507  return Token::SOCKETSET;
5508  }
5509  YY_BREAK
5510 case 254:
5511 YY_RULE_SETUP
5512 #line 2131 "Scanner.ll"
5513 {
5514  if(getIsIdContext())
5515  {
5516  mIsIdAlreadyAdded = true;
5517  REJECT;
5518  }
5519  return Token::STATUS;
5520  }
5521  YY_BREAK
5522 case 255:
5523 YY_RULE_SETUP
5524 #line 2139 "Scanner.ll"
5525 {
5526  if(getIsIdContext())
5527  {
5528  mIsIdAlreadyAdded = true;
5529  REJECT;
5530  }
5531  return Token::STEADY;
5532  }
5533  YY_BREAK
5534 case 256:
5535 YY_RULE_SETUP
5536 #line 2147 "Scanner.ll"
5537 {
5538  if(getIsIdContext())
5539  {
5540  mIsIdAlreadyAdded = true;
5541  REJECT;
5542  }
5543  return Token::STRING;
5544  }
5545  YY_BREAK
5546 case 257:
5547 YY_RULE_SETUP
5548 #line 2155 "Scanner.ll"
5549 {
5550  if(getIsIdContext())
5551  {
5552  mIsIdAlreadyAdded = true;
5553  REJECT;
5554  }
5555  return Token::STRINGDISPLAY;
5556  }
5557  YY_BREAK
5558 case 258:
5559 YY_RULE_SETUP
5560 #line 2163 "Scanner.ll"
5561 {
5562  if(getIsIdContext())
5563  {
5564  mIsIdAlreadyAdded = true;
5565  REJECT;
5566  }
5567  return Token::STRONG;
5568  }
5569  YY_BREAK
5570 case 259:
5571 YY_RULE_SETUP
5572 #line 2171 "Scanner.ll"
5573 {
5574  if(getIsIdContext())
5575  {
5576  mIsIdAlreadyAdded = true;
5577  REJECT;
5578  }
5579  return Token::SYMBOL;
5580  }
5581  YY_BREAK
5582 case 260:
5583 YY_RULE_SETUP
5584 #line 2179 "Scanner.ll"
5585 {
5586  if(getIsIdContext())
5587  {
5588  mIsIdAlreadyAdded = true;
5589  REJECT;
5590  }
5591  return Token::SYMMETRY;
5592  }
5593  YY_BREAK
5594 case 261:
5595 YY_RULE_SETUP
5596 #line 2187 "Scanner.ll"
5597 {
5598  if(getIsIdContext())
5599  {
5600  mIsIdAlreadyAdded = true;
5601  REJECT;
5602  }
5603  return Token::TABLE;
5604  }
5605  YY_BREAK
5606 case 262:
5607 YY_RULE_SETUP
5608 #line 2195 "Scanner.ll"
5609 {
5610  if(getIsIdContext())
5611  {
5612  mIsIdAlreadyAdded = true;
5613  REJECT;
5614  }
5615  return Token::TABLEDEFAULT;
5616  }
5617  YY_BREAK
5618 case 263:
5619 YY_RULE_SETUP
5620 #line 2203 "Scanner.ll"
5621 {
5622  if(getIsIdContext())
5623  {
5624  mIsIdAlreadyAdded = true;
5625  REJECT;
5626  }
5627  return Token::TECHNOLOGY;
5628  }
5629  YY_BREAK
5630 case 264:
5631 YY_RULE_SETUP
5632 #line 2211 "Scanner.ll"
5633 {
5634  if(getIsIdContext())
5635  {
5636  mIsIdAlreadyAdded = true;
5637  REJECT;
5638  }
5639  return Token::TEXTHEIGHT;
5640  }
5641  YY_BREAK
5642 case 265:
5643 YY_RULE_SETUP
5644 #line 2219 "Scanner.ll"
5645 {
5646  if(getIsIdContext())
5647  {
5648  mIsIdAlreadyAdded = true;
5649  REJECT;
5650  }
5651  return Token::TIMEINTERVAL;
5652  }
5653  YY_BREAK
5654 case 266:
5655 YY_RULE_SETUP
5656 #line 2227 "Scanner.ll"
5657 {
5658  if(getIsIdContext())
5659  {
5660  mIsIdAlreadyAdded = true;
5661  REJECT;
5662  }
5663  return Token::TIMESTAMP;
5664  }
5665  YY_BREAK
5666 case 267:
5667 YY_RULE_SETUP
5668 #line 2235 "Scanner.ll"
5669 {
5670  if(getIsIdContext())
5671  {
5672  mIsIdAlreadyAdded = true;
5673  REJECT;
5674  }
5675  return Token::TIMING;
5676  }
5677  YY_BREAK
5678 case 268:
5679 YY_RULE_SETUP
5680 #line 2243 "Scanner.ll"
5681 {
5682  if(getIsIdContext())
5683  {
5684  mIsIdAlreadyAdded = true;
5685  REJECT;
5686  }
5687  return Token::TRANSFORM;
5688  }
5689  YY_BREAK
5690 case 269:
5691 YY_RULE_SETUP
5692 #line 2251 "Scanner.ll"
5693 {
5694  if(getIsIdContext())
5695  {
5696  mIsIdAlreadyAdded = true;
5697  REJECT;
5698  }
5699  return Token::TRANSITION;
5700  }
5701  YY_BREAK
5702 case 270:
5703 YY_RULE_SETUP
5704 #line 2259 "Scanner.ll"
5705 {
5706  if(getIsIdContext())
5707  {
5708  mIsIdAlreadyAdded = true;
5709  REJECT;
5710  }
5711  return Token::TRIGGER;
5712  }
5713  YY_BREAK
5714 case 271:
5715 YY_RULE_SETUP
5716 #line 2267 "Scanner.ll"
5717 {
5718  if(getIsIdContext())
5719  {
5720  mIsIdAlreadyAdded = true;
5721  REJECT;
5722  }
5723  return Token::TRUE;
5724  }
5725  YY_BREAK
5726 case 272:
5727 YY_RULE_SETUP
5728 #line 2275 "Scanner.ll"
5729 {
5730  if(getIsIdContext())
5731  {
5732  mIsIdAlreadyAdded = true;
5733  REJECT;
5734  }
5735  return Token::UNCONSTRAINED;
5736  }
5737  YY_BREAK
5738 case 273:
5739 YY_RULE_SETUP
5740 #line 2283 "Scanner.ll"
5741 {
5742  if(getIsIdContext())
5743  {
5744  mIsIdAlreadyAdded = true;
5745  REJECT;
5746  }
5747  return Token::UNDEFINED;
5748  }
5749  YY_BREAK
5750 case 274:
5751 YY_RULE_SETUP
5752 #line 2291 "Scanner.ll"
5753 {
5754  if(getIsIdContext())
5755  {
5756  mIsIdAlreadyAdded = true;
5757  REJECT;
5758  }
5759  return Token::UNION;
5760  }
5761  YY_BREAK
5762 case 275:
5763 YY_RULE_SETUP
5764 #line 2299 "Scanner.ll"
5765 {
5766  if(getIsIdContext())
5767  {
5768  mIsIdAlreadyAdded = true;
5769  REJECT;
5770  }
5771  return Token::UNIT;
5772  }
5773  YY_BREAK
5774 case 276:
5775 YY_RULE_SETUP
5776 #line 2307 "Scanner.ll"
5777 {
5778  if(getIsIdContext())
5779  {
5780  mIsIdAlreadyAdded = true;
5781  REJECT;
5782  }
5783  return Token::UNUSED;
5784  }
5785  YY_BREAK
5786 case 277:
5787 YY_RULE_SETUP
5788 #line 2315 "Scanner.ll"
5789 {
5790  if(getIsIdContext())
5791  {
5792  mIsIdAlreadyAdded = true;
5793  REJECT;
5794  }
5795  setIsIdContext(true);
5796  return Token::USERDATA;
5797  }
5798  YY_BREAK
5799 case 278:
5800 YY_RULE_SETUP
5801 #line 2324 "Scanner.ll"
5802 {
5803  if(getIsIdContext())
5804  {
5805  mIsIdAlreadyAdded = true;
5806  REJECT;
5807  }
5808  return Token::VERSION;
5809  }
5810  YY_BREAK
5811 case 279:
5812 YY_RULE_SETUP
5813 #line 2332 "Scanner.ll"
5814 {
5815  if(getIsIdContext())
5816  {
5817  mIsIdAlreadyAdded = true;
5818  REJECT;
5819  }
5820  setIsIdContext(true);
5821  return Token::VIEW;
5822  }
5823  YY_BREAK
5824 case 280:
5825 YY_RULE_SETUP
5826 #line 2341 "Scanner.ll"
5827 {
5828  if(getIsIdContext())
5829  {
5830  mIsIdAlreadyAdded = true;
5831  REJECT;
5832  }
5833  return Token::VIEWLIST;
5834  }
5835  YY_BREAK
5836 case 281:
5837 YY_RULE_SETUP
5838 #line 2349 "Scanner.ll"
5839 {
5840  if(getIsIdContext())
5841  {
5842  mIsIdAlreadyAdded = true;
5843  REJECT;
5844  }
5845  return Token::VIEWMAP;
5846  }
5847  YY_BREAK
5848 case 282:
5849 YY_RULE_SETUP
5850 #line 2357 "Scanner.ll"
5851 {
5852  if(getIsIdContext())
5853  {
5854  mIsIdAlreadyAdded = true;
5855  REJECT;
5856  }
5857  setIsIdContext(true);
5858  return Token::VIEWREF;
5859  }
5860  YY_BREAK
5861 case 283:
5862 YY_RULE_SETUP
5863 #line 2366 "Scanner.ll"
5864 {
5865  if(getIsIdContext())
5866  {
5867  mIsIdAlreadyAdded = true;
5868  REJECT;
5869  }
5870  return Token::VIEWTYPE;
5871  }
5872  YY_BREAK
5873 case 284:
5874 YY_RULE_SETUP
5875 #line 2374 "Scanner.ll"
5876 {
5877  if(getIsIdContext())
5878  {
5879  mIsIdAlreadyAdded = true;
5880  REJECT;
5881  }
5882  return Token::VISIBLE;
5883  }
5884  YY_BREAK
5885 case 285:
5886 YY_RULE_SETUP
5887 #line 2382 "Scanner.ll"
5888 {
5889  if(getIsIdContext())
5890  {
5891  mIsIdAlreadyAdded = true;
5892  REJECT;
5893  }
5894  return Token::VOLTAGEMAP;
5895  }
5896  YY_BREAK
5897 case 286:
5898 YY_RULE_SETUP
5899 #line 2390 "Scanner.ll"
5900 {
5901  if(getIsIdContext())
5902  {
5903  mIsIdAlreadyAdded = true;
5904  REJECT;
5905  }
5906  setIsIdContext(true);
5907  return Token::WAVEVALUE;
5908  }
5909  YY_BREAK
5910 case 287:
5911 YY_RULE_SETUP
5912 #line 2399 "Scanner.ll"
5913 {
5914  if(getIsIdContext())
5915  {
5916  mIsIdAlreadyAdded = true;
5917  REJECT;
5918  }
5919  return Token::WEAK;
5920  }
5921  YY_BREAK
5922 case 288:
5923 YY_RULE_SETUP
5924 #line 2407 "Scanner.ll"
5925 {
5926  if(getIsIdContext())
5927  {
5928  mIsIdAlreadyAdded = true;
5929  REJECT;
5930  }
5931  return Token::WEAKJOINED;
5932  }
5933  YY_BREAK
5934 case 289:
5935 YY_RULE_SETUP
5936 #line 2415 "Scanner.ll"
5937 {
5938  if(getIsIdContext())
5939  {
5940  mIsIdAlreadyAdded = true;
5941  REJECT;
5942  }
5943  return Token::WHEN;
5944  }
5945  YY_BREAK
5946 case 290:
5947 YY_RULE_SETUP
5948 #line 2423 "Scanner.ll"
5949 {
5950  if(getIsIdContext())
5951  {
5952  mIsIdAlreadyAdded = true;
5953  REJECT;
5954  }
5955  return Token::WRITTEN;
5956  }
5957  YY_BREAK
5958 case 291:
5959 YY_RULE_SETUP
5960 #line 2433 "Scanner.ll"
5961 {
5962  yylval->stringVal = new std::string(yytext, yyleng);
5963  setIsIdContext(false);
5964  return Token::IDENTIFIER;
5965  }
5966  YY_BREAK
5967 case 292:
5968 YY_RULE_SETUP
5969 #line 2439 "Scanner.ll"
5970 { yylval->integerVal = atoi(yytext);
5971  return Token::INTEGER;
5972  }
5973  YY_BREAK
5974 case 293:
5975 YY_RULE_SETUP
5976 #line 2443 "Scanner.ll"
5977 { yylval->doubleVal = atof(yytext);
5978  return Token::DOUBLE;
5979  }
5980  YY_BREAK
5981 case 294:
5982 /* rule 294 can match eol */
5983 YY_RULE_SETUP
5984 #line 2447 "Scanner.ll"
5985 {
5986  yylval->stringVal = new std::string(yytext +1, yyleng -2);
5987  return Token::STRING;
5988  }
5989  YY_BREAK
5990 /* gobble up white-spaces */
5991 case 295:
5992 YY_RULE_SETUP
5993 #line 2454 "Scanner.ll"
5994 {
5995  yylloc->step();
5996 }
5997  YY_BREAK
5998 /* gobble up end-of-lines */
5999 case 296:
6000 /* rule 296 can match eol */
6001 YY_RULE_SETUP
6002 #line 2459 "Scanner.ll"
6003 {
6004  yylloc->lines(yyleng); yylloc->step();
6005  /* return Token::EOL; */
6006 }
6007  YY_BREAK
6008 /* pass all other characters up to bison */
6009 case 297:
6010 YY_RULE_SETUP
6011 #line 2465 "Scanner.ll"
6012 {
6013  return static_cast<TokenType>(*yytext);
6014 }
6015  YY_BREAK
6016 case 298:
6017 YY_RULE_SETUP
6018 #line 2470 "Scanner.ll"
6019 ECHO;
6020  YY_BREAK
6021 #line 6020 "lex.Edif.cc"
6022  case YY_STATE_EOF(INITIAL):
6023  yyterminate();
6024 
6025  case YY_END_OF_BUFFER:
6026  {
6027  /* Amount of text matched not including the EOB char. */
6028  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
6029 
6030  /* Undo the effects of YY_DO_BEFORE_ACTION. */
6031  *yy_cp = (yy_hold_char);
6032  YY_RESTORE_YY_MORE_OFFSET
6033 
6034  if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW)
6035  {
6036  /* We're scanning a new file or input source. It's
6037  * possible that this happened because the user
6038  * just pointed yyin at a new source and called
6039  * yylex(). If so, then we have to assure
6040  * consistency between YY_CURRENT_BUFFER and our
6041  * globals. Here is the right place to do so, because
6042  * this is the first action (other than possibly a
6043  * back-up) that will match for the new input source.
6044  */
6045  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
6046  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
6047  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
6048  }
6049 
6050  /* Note that here we test for yy_c_buf_p "<=" to the position
6051  * of the first EOB in the buffer, since yy_c_buf_p will
6052  * already have been incremented past the NUL character
6053  * (since all states make transitions on EOB to the
6054  * end-of-buffer state). Contrast this with the test
6055  * in input().
6056  */
6057  if ((yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)])
6058  { /* This was really a NUL. */
6059  yy_state_type yy_next_state;
6060 
6061  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
6062 
6063  yy_current_state = yy_get_previous_state();
6064 
6065  /* Okay, we're now positioned to make the NUL
6066  * transition. We couldn't have
6067  * yy_get_previous_state() go ahead and do it
6068  * for us because it doesn't know how to deal
6069  * with the possibility of jamming (and we don't
6070  * want to build jamming into it because then it
6071  * will run more slowly).
6072  */
6073 
6074  yy_next_state = yy_try_NUL_trans(yy_current_state);
6075 
6076  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
6077 
6078  if (yy_next_state)
6079  {
6080  /* Consume the NUL. */
6081  yy_cp = ++(yy_c_buf_p);
6082  yy_current_state = yy_next_state;
6083  goto yy_match;
6084  }
6085 
6086  else
6087  {
6088 /* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */
6089  yy_cp = (yy_c_buf_p);
6090  goto yy_find_action;
6091  }
6092  }
6093 
6094  else switch (yy_get_next_buffer() )
6095  {
6096  case EOB_ACT_END_OF_FILE:
6097  {
6098  (yy_did_buffer_switch_on_eof) = 0;
6099 
6100  if (yywrap() )
6101  {
6102  /* Note: because we've taken care in
6103  * yy_get_next_buffer() to have set up
6104  * yytext, we can now set up
6105  * yy_c_buf_p so that if some total
6106  * hoser (like flex itself) wants to
6107  * call the scanner after we return the
6108  * YY_NULL, it'll still work - another
6109  * YY_NULL will get returned.
6110  */
6111  (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
6112 
6113  yy_act = YY_STATE_EOF(YY_START);
6114  goto do_action;
6115  }
6116 
6117  else
6118  {
6119  if (! (yy_did_buffer_switch_on_eof))
6120  YY_NEW_FILE;
6121  }
6122  break;
6123  }
6124 
6125  case EOB_ACT_CONTINUE_SCAN:
6126  (yy_c_buf_p) =
6127  (yytext_ptr) + yy_amount_of_matched_text;
6128 
6129  yy_current_state = yy_get_previous_state();
6130 
6131  yy_cp = (yy_c_buf_p);
6132  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
6133  goto yy_match;
6134 
6135  case EOB_ACT_LAST_MATCH:
6136  (yy_c_buf_p) =
6137  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
6138 
6139  yy_current_state = yy_get_previous_state();
6140 
6141  yy_cp = (yy_c_buf_p);
6142  yy_bp = (yytext_ptr) + YY_MORE_ADJ;
6143  goto yy_find_action;
6144  }
6145  break;
6146  }
6147 
6148  default:
6149  YY_FATAL_ERROR(
6150  "fatal flex scanner internal error--no action found" );
6151  } /* end of action switch */
6152  } /* end of scanning one token */
yy_acclist
static yyconst flex_int16_t yy_acclist[2063]
Definition: Scanner.cc:409
INITIAL
#define INITIAL
Definition: Scanner.cc:2171
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: Scanner.cc:2113
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: Scanner.cc:217
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: Scanner.cc:2114
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: Scanner.cc:401
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: Scanner.cc:296
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: Scanner.cc:390
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: Scanner.cc:161
yy_nxt
static yyconst flex_int16_t yy_nxt[3603]
Definition: Scanner.cc:1265
yyterminate
#define yyterminate()
Definition: Scanner.cc:2149
torc::bitstream::string
std::string string
Definition: LibGenFactory.hpp:35
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: Scanner.cc:2270
yy_act
register int yy_act
Definition: Scanner.cc:2323
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: Scanner.cc:215
YY_BREAK
#define YY_BREAK
Definition: Scanner.cc:2308
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: Scanner.cc:295
yy_rule_linenum
static yyconst flex_int16_t yy_rule_linenum[298]
Definition: Scanner.cc:2067
yytext_ptr
#define yytext_ptr
Definition: Scanner.cc:380
yyleng
int yyleng
yy_ec
static yyconst flex_int32_t yy_ec[256]
Definition: Scanner.cc:834
yy_def
static yyconst flex_int16_t yy_def[1724]
Definition: Scanner.cc:1071
yy_base
static yyconst flex_int16_t yy_base[1724]
Definition: Scanner.cc:877
yy_meta
static yyconst flex_int32_t yy_meta[71]
Definition: Scanner.cc:866
REJECT
#define REJECT
Definition: Scanner.cc:2104
yy_cp
register char * yy_cp
Definition: Scanner.cc:2322
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: Scanner.cc:216
yy_accept
static yyconst flex_int16_t yy_accept[1722]
Definition: Scanner.cc:640
YY_NEW_FILE
#define YY_NEW_FILE
Definition: Scanner.cc:188
yy_current_state
YY_DECL register yy_state_type yy_current_state
Definition: Scanner.cc:2321
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: Scanner.cc:334
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: Scanner.cc:185
yy_chk
static yyconst flex_int16_t yy_chk[3603]
Definition: Scanner.cc:1666
YY_CHAR
unsigned char YY_CHAR
Bison lexer internals.
Definition: LutScanner.cpp:307
yy_bp
register char * yy_bp
Definition: Scanner.cc:2322
ECHO
#define ECHO
Definition: Scanner.cc:2234
YY_START
#define YY_START
Definition: Scanner.cc:181
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: Scanner.cc:2312

Variable Documentation

yyconst flex_int16_t yy_accept[1722]
static

Definition at line 640 of file Scanner.cc.

yyconst flex_int16_t yy_acclist[2063]
static

Definition at line 409 of file Scanner.cc.

register int yy_act

Definition at line 2323 of file Scanner.cc.

yyconst flex_int16_t yy_base[1724]
static

Definition at line 877 of file Scanner.cc.

register char * yy_bp

Definition at line 2322 of file Scanner.cc.

yyconst flex_int16_t yy_chk[3603]
static

Definition at line 1666 of file Scanner.cc.

register char* yy_cp

Definition at line 2322 of file Scanner.cc.

YY_DECL register yy_state_type yy_current_state

The main scanner function which does all the work.

Definition at line 2321 of file Scanner.cc.

yyconst flex_int16_t yy_def[1724]
static

Definition at line 1071 of file Scanner.cc.

yyconst flex_int32_t yy_ec[256]
static

Definition at line 834 of file Scanner.cc.

yyconst flex_int32_t yy_meta[71]
static
Initial value:
=
{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2
}

Definition at line 866 of file Scanner.cc.

yyconst flex_int16_t yy_nxt[3603]
static

Definition at line 1265 of file Scanner.cc.

yyconst flex_int16_t yy_rule_linenum[298]
static

Definition at line 2067 of file Scanner.cc.

int yyleng