Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
vhdl::parser::VhdlParserTokenManager Class Reference

#include <VhdlParserTokenManager.h>

Inheritance diagram for vhdl::parser::VhdlParserTokenManager:
vhdl::parser::TokenManager

Public Member Functions

void setDebugStream (FILE *ds)
 
int jjStopAtPos (int pos, int kind)
 
int jjMoveStringLiteralDfa0_0 ()
 
int jjMoveStringLiteralDfa1_0 (unsigned long long active0, unsigned long long active1, unsigned long long active2)
 
int jjMoveStringLiteralDfa2_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2)
 
int jjMoveStringLiteralDfa3_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2)
 
int jjMoveStringLiteralDfa4_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa5_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa6_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa7_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa8_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa9_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa10_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa11_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa12_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa13_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa14_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa15_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa16_0 (unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
 
int jjMoveStringLiteralDfa17_0 (unsigned long long old1, unsigned long long active1)
 
int jjMoveNfa_0 (int startState, int curPos)
 
bool jjCanMove_0 (int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2)
 
bool jjCanMove_1 (int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2)
 
Token * jjFillToken ()
 
Token * getNextToken ()
 
void SkipLexicalActions (Token *matchedToken)
 
void TokenLexicalActions (Token *matchedToken)
 
 VhdlParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState=0, VhdlParser *parserArg=NULL)
 
virtual ~VhdlParserTokenManager ()
 
void ReInit (JAVACC_CHARSTREAM *stream, int lexState=0, VhdlParser *parserArg=NULL)
 
void SwitchTo (int lexState)
 
void clear ()
 
const JAVACC_SIMPLE_STRING jjKindsForBitVector (int i, unsigned long long vec)
 
const JAVACC_SIMPLE_STRING jjKindsForStateVector (int lexState, int vec[], int start, int end)
 
void setErrorHandler (TokenManagerErrorHandler *eh)
 
- Public Member Functions inherited from vhdl::parser::TokenManager
virtual ~TokenManager ()
 
virtual void lexicalError ()
 

Public Attributes

FILE * debugStream
 
int curLexState
 
int jjnewStateCnt
 
int jjround
 
int jjmatchedPos
 
int jjmatchedKind
 
JAVACC_CHARSTREAM * input_stream
 
int jjrounds [76]
 
int jjstateSet [2 *76]
 
JAVACC_STRING_TYPE jjimage
 
JAVACC_STRING_TYPE image
 
int jjimageLen
 
int lengthOfMatch
 
JAVACC_CHAR_TYPE curChar
 
TokenManagerErrorHandler * errorHandler
 
bool errorHandlerCreated
 

Private Member Functions

void ReInitRounds ()
 

Private Attributes

VhdlParser * parser
 

Detailed Description

Token Manager.

Definition at line 17 of file VhdlParserTokenManager.h.

Constructor & Destructor Documentation

vhdl::parser::VhdlParserTokenManager::VhdlParserTokenManager ( JAVACC_CHARSTREAM *  stream,
int  lexState = 0,
VhdlParser *  parserArg = NULL 
)

Constructor.

Definition at line 3625 of file VhdlParserTokenManager.cc.

3626  {
3627  input_stream = NULL;
3628  errorHandlerCreated = false;
3629  ReInit(stream, lexState, parserArg);
3630  }
vhdl::parser::VhdlParserTokenManager::ReInit
void ReInit(JAVACC_CHARSTREAM *stream, int lexState=0, VhdlParser *parserArg=NULL)
Definition: VhdlParserTokenManager.cc:3588
generate_datataset.stream
stream
Definition: generate_datataset.py:30
vhdl::parser::VhdlParserTokenManager::~VhdlParserTokenManager ( )
virtual

Definition at line 3633 of file VhdlParserTokenManager.cc.

3633  {
3634  clear();
3635  }

Member Function Documentation

void vhdl::parser::VhdlParserTokenManager::clear ( )

Definition at line 3638 of file VhdlParserTokenManager.cc.

3638  {
3639  //Since input_stream was generated outside of TokenManager
3640  //TokenManager should not take care of deleting it
3641  //if (input_stream) delete input_stream;
3642  if (errorHandlerCreated) delete errorHandler;
3643  }
Token * vhdl::parser::VhdlParserTokenManager::getNextToken ( )
virtual

Get the next Token.

Implements vhdl::parser::TokenManager.

Definition at line 3347 of file VhdlParserTokenManager.cc.

3347  {
3348  Token *matchedToken;
3349  int curPos = 0;
3350 
3351  for (;;)
3352  {
3353  EOFLoop:
3354  if (input_stream->endOfInput())
3355  {
3356  jjmatchedKind = 0;
3357  jjmatchedPos = -1;
3358  matchedToken = jjFillToken();
3359  return matchedToken;
3360  }
3361  curChar = input_stream->BeginToken();
3362  image = jjimage;
3363  image.clear();
3364  jjimageLen = 0;
3365 
3366  jjmatchedKind = 0x7fffffff;
3367  jjmatchedPos = 0;
3368  curPos = jjMoveStringLiteralDfa0_0();
3369  if (jjmatchedKind != 0x7fffffff)
3370  {
3371  if (jjmatchedPos + 1 < curPos)
3372  input_stream->backup(curPos - jjmatchedPos - 1);
3373  if ((jjtoToken[jjmatchedKind >> 6] & (1ULL << (jjmatchedKind & 077))) != 0L)
3374  {
3375  matchedToken = jjFillToken();
3376  TokenLexicalActions(matchedToken);
3377  return matchedToken;
3378  }
3379  else
3380  {
3381  SkipLexicalActions(NULL);
3382  goto EOFLoop;
3383  }
3384  }
3385  int error_line = input_stream->getEndLine();
3386  int error_column = input_stream->getEndColumn();
3387  JAVACC_STRING_TYPE error_after;
3388  bool EOFSeen = false;
3389  if (input_stream->endOfInput()) {
3390  EOFSeen = true;
3391  error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
3392  if (curChar == '\n' || curChar == '\r') {
3393  error_line++;
3394  error_column = 0;
3395  }
3396  else
3397  error_column++;
3398  }
3399  if (!EOFSeen) {
3400  error_after = curPos <= 1 ? EMPTY : input_stream->GetImage();
3401  }
3402  errorHandler->lexicalError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, this);
3403  }
3404 }
vhdl::parser::jjtoToken
static const unsigned long long jjtoToken[]
Definition: VhdlParserTokenManager.cc:436
JAVACC_STRING_TYPE
#define JAVACC_STRING_TYPE
Definition: JavaCC.h:16
EMPTY
const JAVACC_CHAR_TYPE EMPTY[]
Definition: JavaCC.h:33
vhdl::parser::TokenManagerErrorHandler::lexicalError
virtual void lexicalError(bool EOFSeen, int lexState, int errorLine, int errorColumn, JAVACC_STRING_TYPE errorAfter, JAVACC_CHAR_TYPE curChar, VhdlParserTokenManager *token_manager)
Definition: ErrorHandler.h:65
bool vhdl::parser::VhdlParserTokenManager::jjCanMove_0 ( int  hiByte,
int  i1,
int  i2,
unsigned long long  l1,
unsigned long long  l2 
)

Definition at line 3290 of file VhdlParserTokenManager.cc.

3290  {
3291  switch(hiByte)
3292  {
3293  case 0:
3294  return ((jjbitVec2[i2] & l2) != 0L);
3295  default :
3296  if ((jjbitVec0[i1] & l1) != 0L)
3297  return true;
3298  return false;
3299  }
3300 }
vhdl::parser::jjbitVec2
static const unsigned long long jjbitVec2[]
Definition: VhdlParserTokenManager.cc:9
vhdl::parser::jjbitVec0
static const unsigned long long jjbitVec0[]
Definition: VhdlParserTokenManager.cc:6
bool vhdl::parser::VhdlParserTokenManager::jjCanMove_1 ( int  hiByte,
int  i1,
int  i2,
unsigned long long  l1,
unsigned long long  l2 
)

Definition at line 3302 of file VhdlParserTokenManager.cc.

3302  {
3303  switch(hiByte)
3304  {
3305  case 0:
3306  return ((jjbitVec3[i2] & l2) != 0L);
3307  default :
3308  return false;
3309  }
3310 }
vhdl::parser::jjbitVec3
static const unsigned long long jjbitVec3[]
Definition: VhdlParserTokenManager.cc:12
Token * vhdl::parser::VhdlParserTokenManager::jjFillToken ( )

Token literal values.

Definition at line 3314 of file VhdlParserTokenManager.cc.

3314  {
3315  Token *t;
3316  JAVACC_STRING_TYPE curTokenImage;
3317  int beginLine = -1;
3318  int endLine = -1;
3319  int beginColumn = -1;
3320  int endColumn = -1;
3321  JAVACC_STRING_TYPE im = jjstrLiteralImages[jjmatchedKind];
3322  curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
3323  if (input_stream->getTrackLineColumn()) {
3324  beginLine = input_stream->getBeginLine();
3325  beginColumn = input_stream->getBeginColumn();
3326  endLine = input_stream->getEndLine();
3327  endColumn = input_stream->getEndColumn();
3328  }
3329  t = Token::newToken(jjmatchedKind);
3330  t->kind = jjmatchedKind;
3331  t->image = curTokenImage;
3332  t->specialToken = NULL;
3333  t->next = NULL;
3334 
3335  if (input_stream->getTrackLineColumn()) {
3336  t->beginLine = beginLine;
3337  t->endLine = endLine;
3338  t->beginColumn = beginColumn;
3339  t->endColumn = endColumn;
3340  }
3341 
3342  return t;
3343 }
JAVACC_STRING_TYPE
#define JAVACC_STRING_TYPE
Definition: JavaCC.h:16
reco_momentum_tuples.t
t
Definition: reco_momentum_tuples.py:25
vhdl::parser::Token::newToken
static Token * newToken(int ofKind, JAVACC_STRING_TYPE image)
Definition: Token.cc:73
vhdl::parser::jjstrLiteralImages
static const JAVACC_STRING_TYPE jjstrLiteralImages[]
Definition: VhdlParserTokenManager.cc:239
const JAVACC_SIMPLE_STRING vhdl::parser::VhdlParserTokenManager::jjKindsForBitVector ( int  i,
unsigned long long  vec 
)
const JAVACC_SIMPLE_STRING vhdl::parser::VhdlParserTokenManager::jjKindsForStateVector ( int  lexState,
int  vec[],
int  start,
int  end 
)
int vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0 ( int  startState,
int  curPos 
)

Definition at line 2677 of file VhdlParserTokenManager.cc.

2677  {
2678  int strKind = jjmatchedKind;
2679  int strPos = jjmatchedPos;
2680  int seenUpto;
2681  input_stream->backup(seenUpto = curPos + 1);
2682  assert(!input_stream->endOfInput());
2683  curChar = input_stream->readChar();
2684  curPos = 0;
2685  int startsAt = 0;
2686  jjnewStateCnt = 76;
2687  int i = 1;
2688  jjstateSet[0] = startState;
2689  int kind = 0x7fffffff;
2690  for (;;)
2691  {
2692  if (++jjround == 0x7fffffff)
2693  ReInitRounds();
2694  if (curChar < 64)
2695  {
2696  unsigned long long l = 1ULL << curChar;
2697  (void)l;
2698  do
2699  {
2700  switch(jjstateSet[--i])
2701  {
2702  case 11:
2703  if ((0x3ff000000000000ULL & l) != 0L)
2704  {
2705  if (kind > 165)
2706  kind = 165;
2707  { jjCheckNAddStates(0, 8); }
2708  }
2709  else if ((0x100000200ULL & l) != 0L)
2710  { jjCheckNAddTwoStates(0, 3); }
2711  else if (curChar == 47)
2712  { jjAddStates(9, 10); }
2713  else if (curChar == 45)
2714  { jjCheckNAddStates(11, 13); }
2715  else if (curChar == 39)
2716  jjstateSet[jjnewStateCnt++] = 18;
2717  else if (curChar == 34)
2718  { jjCheckNAddTwoStates(9, 10); }
2719  if ((0x3ff000000000000ULL & l) != 0L)
2720  {
2721  if (kind > 171)
2722  kind = 171;
2723  { jjCheckNAdd(20); }
2724  }
2725  break;
2726  case 0:
2727  if ((0x100000200ULL & l) != 0L)
2728  { jjCheckNAddTwoStates(0, 3); }
2729  break;
2730  case 1:
2731  if (curChar != 33)
2732  break;
2733  if (kind > 6)
2734  kind = 6;
2735  { jjCheckNAddStates(14, 18); }
2736  break;
2737  case 2:
2738  if (curChar == 45)
2739  jjstateSet[jjnewStateCnt++] = 1;
2740  break;
2741  case 3:
2742  if (curChar == 45)
2743  { jjCheckNAdd(2); }
2744  break;
2745  case 4:
2746  if ((0xffffffffffffdbffULL & l) == 0L)
2747  break;
2748  if (kind > 6)
2749  kind = 6;
2750  { jjCheckNAddStates(14, 18); }
2751  break;
2752  case 5:
2753  if ((0x2400ULL & l) == 0L)
2754  break;
2755  if (kind > 6)
2756  kind = 6;
2757  { jjCheckNAddTwoStates(0, 3); }
2758  break;
2759  case 6:
2760  if (curChar != 10)
2761  break;
2762  if (kind > 6)
2763  kind = 6;
2764  { jjCheckNAddTwoStates(0, 3); }
2765  break;
2766  case 7:
2767  if (curChar == 13)
2768  jjstateSet[jjnewStateCnt++] = 6;
2769  break;
2770  case 8:
2771  if (curChar == 34)
2772  { jjCheckNAddTwoStates(9, 10); }
2773  break;
2774  case 9:
2775  if ((0xfffffffb00000200ULL & l) != 0L)
2776  { jjCheckNAddTwoStates(9, 10); }
2777  break;
2778  case 10:
2779  if (curChar != 34)
2780  break;
2781  if (kind > 166)
2782  kind = 166;
2783  jjstateSet[jjnewStateCnt++] = 8;
2784  break;
2785  case 13:
2786  if ((0x3ff000000000000ULL & l) == 0L)
2787  break;
2788  if (kind > 167)
2789  kind = 167;
2790  { jjAddStates(19, 20); }
2791  break;
2792  case 15:
2793  if ((0xfffffffb00000200ULL & l) != 0L)
2794  { jjAddStates(21, 22); }
2795  break;
2796  case 17:
2797  if (curChar == 39)
2798  jjstateSet[jjnewStateCnt++] = 18;
2799  break;
2800  case 18:
2801  if ((0xffffffff00000200ULL & l) != 0L)
2802  jjstateSet[jjnewStateCnt++] = 19;
2803  break;
2804  case 19:
2805  if (curChar == 39 && kind > 169)
2806  kind = 169;
2807  break;
2808  case 20:
2809  if ((0x3ff000000000000ULL & l) == 0L)
2810  break;
2811  if (kind > 171)
2812  kind = 171;
2813  { jjCheckNAdd(20); }
2814  break;
2815  case 22:
2816  if (curChar == 34)
2817  { jjCheckNAdd(23); }
2818  break;
2819  case 23:
2820  if ((0x3ff000000000000ULL & l) != 0L)
2821  { jjCheckNAddStates(23, 25); }
2822  break;
2823  case 25:
2824  if (curChar == 34 && kind > 179)
2825  kind = 179;
2826  break;
2827  case 27:
2828  if (curChar == 34)
2829  { jjCheckNAddTwoStates(28, 29); }
2830  break;
2831  case 28:
2832  if ((0xfffffffb00000200ULL & l) != 0L)
2833  { jjCheckNAddTwoStates(28, 29); }
2834  break;
2835  case 29:
2836  if (curChar != 34)
2837  break;
2838  if (kind > 187)
2839  kind = 187;
2840  { jjCheckNAddTwoStates(27, 30); }
2841  break;
2842  case 30:
2843  if ((0xfffffffb00000200ULL & l) == 0L)
2844  break;
2845  if (kind > 187)
2846  kind = 187;
2847  { jjCheckNAddTwoStates(27, 30); }
2848  break;
2849  case 31:
2850  if (curChar == 45)
2851  { jjCheckNAddStates(11, 13); }
2852  break;
2853  case 32:
2854  if (curChar != 35)
2855  break;
2856  if (kind > 7)
2857  kind = 7;
2858  { jjCheckNAddStates(26, 28); }
2859  break;
2860  case 33:
2861  if ((0xffffffffffffdbffULL & l) == 0L)
2862  break;
2863  if (kind > 7)
2864  kind = 7;
2865  { jjCheckNAddStates(26, 28); }
2866  break;
2867  case 34:
2868  if ((0x2400ULL & l) != 0L && kind > 7)
2869  kind = 7;
2870  break;
2871  case 35:
2872  if (curChar == 10 && kind > 7)
2873  kind = 7;
2874  break;
2875  case 36:
2876  if (curChar == 13)
2877  jjstateSet[jjnewStateCnt++] = 35;
2878  break;
2879  case 37:
2880  if (curChar == 45)
2881  jjstateSet[jjnewStateCnt++] = 32;
2882  break;
2883  case 38:
2884  if (curChar != 45)
2885  break;
2886  if (kind > 8)
2887  kind = 8;
2888  { jjCheckNAddStates(29, 31); }
2889  break;
2890  case 39:
2891  if ((0xffffffffffffdbffULL & l) == 0L)
2892  break;
2893  if (kind > 8)
2894  kind = 8;
2895  { jjCheckNAddStates(29, 31); }
2896  break;
2897  case 40:
2898  if ((0x2400ULL & l) != 0L && kind > 8)
2899  kind = 8;
2900  break;
2901  case 41:
2902  if (curChar == 10 && kind > 8)
2903  kind = 8;
2904  break;
2905  case 42:
2906  if (curChar == 13)
2907  jjstateSet[jjnewStateCnt++] = 41;
2908  break;
2909  case 43:
2910  if (curChar == 47)
2911  { jjAddStates(9, 10); }
2912  break;
2913  case 44:
2914  if (curChar == 33)
2915  { jjCheckNAddTwoStates(45, 47); }
2916  break;
2917  case 45:
2918  { jjCheckNAddTwoStates(45, 47); }
2919  break;
2920  case 46:
2921  if (curChar == 47 && kind > 9)
2922  kind = 9;
2923  break;
2924  case 47:
2925  if (curChar == 42)
2926  jjstateSet[jjnewStateCnt++] = 46;
2927  break;
2928  case 48:
2929  if (curChar == 42)
2930  jjstateSet[jjnewStateCnt++] = 44;
2931  break;
2932  case 49:
2933  if (curChar == 42)
2934  { jjCheckNAddTwoStates(50, 52); }
2935  break;
2936  case 50:
2937  { jjCheckNAddTwoStates(50, 52); }
2938  break;
2939  case 51:
2940  if (curChar == 47 && kind > 10)
2941  kind = 10;
2942  break;
2943  case 52:
2944  if (curChar == 42)
2945  jjstateSet[jjnewStateCnt++] = 51;
2946  break;
2947  case 53:
2948  if ((0x3ff000000000000ULL & l) == 0L)
2949  break;
2950  if (kind > 165)
2951  kind = 165;
2952  { jjCheckNAddStates(0, 8); }
2953  break;
2954  case 55:
2955  if ((0x3ff000000000000ULL & l) == 0L)
2956  break;
2957  if (kind > 165)
2958  kind = 165;
2959  { jjCheckNAddTwoStates(54, 55); }
2960  break;
2961  case 57:
2962  if ((0x3ff000000000000ULL & l) == 0L)
2963  break;
2964  if (kind > 170)
2965  kind = 170;
2966  { jjCheckNAddStates(32, 35); }
2967  break;
2968  case 58:
2969  if (curChar == 46)
2970  { jjCheckNAdd(59); }
2971  break;
2972  case 59:
2973  if ((0x3ff000000000000ULL & l) == 0L)
2974  break;
2975  if (kind > 170)
2976  kind = 170;
2977  { jjCheckNAddStates(36, 38); }
2978  break;
2979  case 62:
2980  if ((0x280000000000ULL & l) != 0L)
2981  { jjCheckNAdd(63); }
2982  break;
2983  case 63:
2984  if ((0x3ff000000000000ULL & l) == 0L)
2985  break;
2986  if (kind > 170)
2987  kind = 170;
2988  { jjCheckNAddTwoStates(64, 63); }
2989  break;
2990  case 66:
2991  if ((0x3ff000000000000ULL & l) != 0L)
2992  { jjCheckNAddStates(39, 41); }
2993  break;
2994  case 67:
2995  if (curChar == 35)
2996  { jjCheckNAdd(68); }
2997  break;
2998  case 68:
2999  if ((0x3ff000000000000ULL & l) != 0L)
3000  { jjCheckNAddStates(42, 44); }
3001  break;
3002  case 69:
3003  if (curChar == 46)
3004  { jjCheckNAdd(70); }
3005  break;
3006  case 70:
3007  if ((0x3ff000000000000ULL & l) != 0L)
3008  { jjCheckNAddTwoStates(70, 71); }
3009  break;
3010  case 71:
3011  if (curChar != 35)
3012  break;
3013  if (kind > 172)
3014  kind = 172;
3015  jjstateSet[jjnewStateCnt++] = 72;
3016  break;
3017  case 73:
3018  if ((0x280000000000ULL & l) != 0L)
3019  { jjCheckNAdd(74); }
3020  break;
3021  case 74:
3022  if ((0x3ff000000000000ULL & l) == 0L)
3023  break;
3024  if (kind > 172)
3025  kind = 172;
3026  { jjCheckNAddTwoStates(75, 74); }
3027  break;
3028  default : break;
3029  }
3030  } while(i != startsAt);
3031  }
3032  else if (curChar < 128)
3033  {
3034  unsigned long long l = 1ULL << (curChar & 077);
3035  (void)l;
3036  do
3037  {
3038  switch(jjstateSet[--i])
3039  {
3040  case 11:
3041  if ((0x7fffffe07fffffeULL & l) != 0L)
3042  {
3043  if (kind > 171)
3044  kind = 171;
3045  { jjCheckNAdd(20); }
3046  }
3047  else if (curChar == 96)
3048  { jjCheckNAddTwoStates(27, 30); }
3049  else if (curChar == 92)
3050  { jjCheckNAddTwoStates(15, 16); }
3051  if ((0x7fffffe07fffffeULL & l) != 0L)
3052  {
3053  if (kind > 167)
3054  kind = 167;
3055  { jjCheckNAddTwoStates(12, 13); }
3056  }
3057  if ((0x100800401008004ULL & l) != 0L)
3058  jjstateSet[jjnewStateCnt++] = 22;
3059  break;
3060  case 4:
3061  if (kind > 6)
3062  kind = 6;
3063  { jjAddStates(14, 18); }
3064  break;
3065  case 9:
3066  if ((0x7fffffffffffffffULL & l) != 0L)
3067  { jjAddStates(45, 46); }
3068  break;
3069  case 12:
3070  if (curChar == 95)
3071  { jjCheckNAddTwoStates(12, 13); }
3072  break;
3073  case 13:
3074  if ((0x7fffffe07fffffeULL & l) == 0L)
3075  break;
3076  if (kind > 167)
3077  kind = 167;
3078  { jjCheckNAddTwoStates(12, 13); }
3079  break;
3080  case 14:
3081  if (curChar == 92)
3082  { jjCheckNAddTwoStates(15, 16); }
3083  break;
3084  case 15:
3085  if ((0x7fffffffffffffffULL & l) != 0L)
3086  { jjCheckNAddTwoStates(15, 16); }
3087  break;
3088  case 16:
3089  if (curChar == 92 && kind > 168)
3090  kind = 168;
3091  break;
3092  case 18:
3093  if ((0x7fffffffffffffffULL & l) != 0L)
3094  jjstateSet[jjnewStateCnt++] = 19;
3095  break;
3096  case 20:
3097  if ((0x7fffffe07fffffeULL & l) == 0L)
3098  break;
3099  if (kind > 171)
3100  kind = 171;
3101  { jjCheckNAdd(20); }
3102  break;
3103  case 21:
3104  if ((0x100800401008004ULL & l) != 0L)
3105  jjstateSet[jjnewStateCnt++] = 22;
3106  break;
3107  case 23:
3108  if ((0x7fffffe07fffffeULL & l) != 0L)
3109  { jjCheckNAddStates(23, 25); }
3110  break;
3111  case 24:
3112  if (curChar == 95)
3113  { jjCheckNAddTwoStates(24, 23); }
3114  break;
3115  case 26:
3116  if (curChar == 96)
3117  { jjCheckNAddTwoStates(27, 30); }
3118  break;
3119  case 28:
3120  if ((0x7fffffffffffffffULL & l) != 0L)
3121  { jjAddStates(47, 48); }
3122  break;
3123  case 30:
3124  if ((0x7fffffffffffffffULL & l) == 0L)
3125  break;
3126  if (kind > 187)
3127  kind = 187;
3128  { jjCheckNAddTwoStates(27, 30); }
3129  break;
3130  case 33:
3131  if (kind > 7)
3132  kind = 7;
3133  { jjAddStates(26, 28); }
3134  break;
3135  case 39:
3136  if (kind > 8)
3137  kind = 8;
3138  { jjAddStates(29, 31); }
3139  break;
3140  case 45:
3141  { jjAddStates(49, 50); }
3142  break;
3143  case 50:
3144  { jjAddStates(51, 52); }
3145  break;
3146  case 54:
3147  if (curChar == 95)
3148  jjstateSet[jjnewStateCnt++] = 55;
3149  break;
3150  case 56:
3151  if (curChar == 95)
3152  jjstateSet[jjnewStateCnt++] = 57;
3153  break;
3154  case 60:
3155  if (curChar == 95)
3156  jjstateSet[jjnewStateCnt++] = 59;
3157  break;
3158  case 61:
3159  if ((0x2000000020ULL & l) != 0L)
3160  { jjCheckNAddTwoStates(62, 63); }
3161  break;
3162  case 64:
3163  if (curChar == 95)
3164  { jjCheckNAdd(63); }
3165  break;
3166  case 65:
3167  if (curChar == 95)
3168  jjstateSet[jjnewStateCnt++] = 66;
3169  break;
3170  case 68:
3171  if ((0x7fffffe07fffffeULL & l) != 0L)
3172  { jjCheckNAddStates(42, 44); }
3173  break;
3174  case 70:
3175  if ((0x7fffffe07fffffeULL & l) != 0L)
3176  { jjCheckNAddTwoStates(70, 71); }
3177  break;
3178  case 72:
3179  if ((0x2000000020ULL & l) != 0L)
3180  { jjCheckNAddTwoStates(73, 74); }
3181  break;
3182  case 75:
3183  if (curChar == 95)
3184  { jjCheckNAdd(74); }
3185  break;
3186  default : break;
3187  }
3188  } while(i != startsAt);
3189  }
3190  else
3191  {
3192  int hiByte = (curChar >> 8);
3193  int i1 = hiByte >> 6;
3194  unsigned long long l1 = 1ULL << (hiByte & 077);
3195  int i2 = (curChar & 0xff) >> 6;
3196  unsigned long long l2 = 1ULL << (curChar & 077);
3197  do
3198  {
3199  switch(jjstateSet[--i])
3200  {
3201  case 4:
3202  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3203  break;
3204  if (kind > 6)
3205  kind = 6;
3206  { jjAddStates(14, 18); }
3207  break;
3208  case 9:
3209  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3210  { jjAddStates(45, 46); }
3211  break;
3212  case 15:
3213  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3214  { jjAddStates(21, 22); }
3215  break;
3216  case 18:
3217  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3218  jjstateSet[jjnewStateCnt++] = 19;
3219  break;
3220  case 28:
3221  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
3222  { jjAddStates(47, 48); }
3223  break;
3224  case 30:
3225  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
3226  break;
3227  if (kind > 187)
3228  kind = 187;
3229  { jjAddStates(53, 54); }
3230  break;
3231  case 33:
3232  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3233  break;
3234  if (kind > 7)
3235  kind = 7;
3236  { jjAddStates(26, 28); }
3237  break;
3238  case 39:
3239  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
3240  break;
3241  if (kind > 8)
3242  kind = 8;
3243  { jjAddStates(29, 31); }
3244  break;
3245  case 45:
3246  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3247  { jjAddStates(49, 50); }
3248  break;
3249  case 50:
3250  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
3251  { jjAddStates(51, 52); }
3252  break;
3253  default : if (i1 == 0 || l1 == 0 || i2 == 0 || l2 == 0) break; else break;
3254  }
3255  } while(i != startsAt);
3256  }
3257  if (kind != 0x7fffffff)
3258  {
3259  jjmatchedKind = kind;
3260  jjmatchedPos = curPos;
3261  kind = 0x7fffffff;
3262  }
3263  ++curPos;
3264  if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 76 - startsAt)))
3265  break;
3266  if (input_stream->endOfInput()) { break; }
3267  curChar = input_stream->readChar();
3268  }
3269  if (jjmatchedPos > strPos)
3270  return curPos;
3271 
3272  int toRet = MAX(curPos, seenUpto);
3273 
3274  if (curPos < toRet)
3275  for (i = toRet - MIN(curPos, seenUpto); i-- > 0; )
3276  { assert(!input_stream->endOfInput());
3277  curChar = input_stream->readChar(); }
3278 
3279  if (jjmatchedPos < strPos)
3280  {
3281  jjmatchedKind = strKind;
3282  jjmatchedPos = strPos;
3283  }
3284  else if (jjmatchedPos == strPos && jjmatchedKind > strKind)
3285  jjmatchedKind = strKind;
3286 
3287  return toRet;
3288 }
jjCheckNAddTwoStates
#define jjCheckNAddTwoStates(state1, state2)
Definition: VhdlParserTokenManager.h:98
jjAddStates
#define jjAddStates(start, end)
Definition: VhdlParserTokenManager.h:92
vhdl::parser::VhdlParserTokenManager::jjCanMove_1
bool jjCanMove_1(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2)
Definition: VhdlParserTokenManager.cc:3302
jjCheckNAdd
#define jjCheckNAdd(state)
Definition: VhdlParserTokenManager.h:84
l
static QStrList * l
Definition: config.cpp:1044
jjCheckNAddStates
#define jjCheckNAddStates(start, end)
Definition: VhdlParserTokenManager.h:104
vhdl::parser::VhdlParserTokenManager::jjCanMove_0
bool jjCanMove_0(int hiByte, int i1, int i2, unsigned long long l1, unsigned long long l2)
Definition: VhdlParserTokenManager.cc:3290
MIN
#define MIN(x, y)
Definition: define.h:17
MAX
#define MAX(x, y)
Definition: define.h:16
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa0_0 ( )

Definition at line 451 of file VhdlParserTokenManager.cc.

451  {
452  switch(curChar)
453  {
454  case 9:
455  jjmatchedKind = 2;
456  return jjMoveNfa_0(11, 0);
457  case 10:
458  jjmatchedKind = 3;
459  return jjMoveNfa_0(11, 0);
460  case 13:
461  jjmatchedKind = 4;
462  return jjMoveNfa_0(11, 0);
463  case 32:
464  jjmatchedKind = 1;
465  return jjMoveNfa_0(11, 0);
466  case 38:
467  jjmatchedKind = 126;
468  return jjMoveNfa_0(11, 0);
469  case 39:
470  jjmatchedKind = 127;
471  return jjMoveNfa_0(11, 0);
472  case 40:
473  jjmatchedKind = 128;
474  return jjMoveNfa_0(11, 0);
475  case 41:
476  jjmatchedKind = 129;
477  return jjMoveNfa_0(11, 0);
478  case 42:
479  jjmatchedKind = 131;
480  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x4ULL);
481  case 43:
482  jjmatchedKind = 132;
483  return jjMoveNfa_0(11, 0);
484  case 44:
485  jjmatchedKind = 134;
486  return jjMoveNfa_0(11, 0);
487  case 45:
488  jjmatchedKind = 133;
489  return jjMoveNfa_0(11, 0);
490  case 46:
491  jjmatchedKind = 157;
492  return jjMoveNfa_0(11, 0);
493  case 47:
494  jjmatchedKind = 158;
495  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x8000ULL);
496  case 58:
497  jjmatchedKind = 136;
498  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x80ULL);
499  case 59:
500  jjmatchedKind = 137;
501  return jjMoveNfa_0(11, 0);
502  case 60:
503  jjmatchedKind = 140;
504  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x60400ULL);
505  case 61:
506  jjmatchedKind = 142;
507  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x10000ULL);
508  case 62:
509  jjmatchedKind = 141;
510  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x80800ULL);
511  case 63:
512  jjmatchedKind = 155;
513  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x0ULL, 0x7f00000ULL);
514  case 64:
515  jjmatchedKind = 159;
516  return jjMoveNfa_0(11, 0);
517  case 65:
518  return jjMoveStringLiteralDfa1_0(0x7ff800ULL, 0x0ULL, 0x0ULL);
519  case 66:
520  return jjMoveStringLiteralDfa1_0(0xf800000ULL, 0x0ULL, 0x0ULL);
521  case 67:
522  return jjMoveStringLiteralDfa1_0(0x3f0000000ULL, 0x0ULL, 0x0ULL);
523  case 68:
524  return jjMoveStringLiteralDfa1_0(0x1c00000000ULL, 0x0ULL, 0x0ULL);
525  case 69:
526  return jjMoveStringLiteralDfa1_0(0x3e000000000ULL, 0x0ULL, 0x0ULL);
527  case 70:
528  return jjMoveStringLiteralDfa1_0(0x7c0000000000ULL, 0x0ULL, 0x0ULL);
529  case 71:
530  return jjMoveStringLiteralDfa1_0(0x7800000000000ULL, 0x0ULL, 0x0ULL);
531  case 73:
532  return jjMoveStringLiteralDfa1_0(0x1f8000000000000ULL, 0x0ULL, 0x0ULL);
533  case 76:
534  return jjMoveStringLiteralDfa1_0(0x3e00000000000000ULL, 0x0ULL, 0x0ULL);
535  case 77:
536  return jjMoveStringLiteralDfa1_0(0xc000000000000000ULL, 0x0ULL, 0x0ULL);
537  case 78:
538  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3fULL, 0x0ULL);
539  case 79:
540  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xfc0ULL, 0x0ULL);
541  case 80:
542  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ff000ULL, 0x0ULL);
543  case 82:
544  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ffe00000ULL, 0x0ULL);
545  case 83:
546  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xffe00000000ULL, 0x0ULL);
547  case 84:
548  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000ULL, 0x0ULL);
549  case 85:
550  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf000000000000ULL, 0x0ULL);
551  case 86:
552  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf0000000000000ULL, 0x0ULL);
553  case 87:
554  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000000ULL, 0x0ULL);
555  case 88:
556  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3000000000000000ULL, 0x0ULL);
557  case 91:
558  jjmatchedKind = 161;
559  return jjMoveNfa_0(11, 0);
560  case 93:
561  jjmatchedKind = 162;
562  return jjMoveNfa_0(11, 0);
563  case 94:
564  jjmatchedKind = 160;
565  return jjMoveNfa_0(11, 0);
566  case 97:
567  return jjMoveStringLiteralDfa1_0(0x7ff800ULL, 0x0ULL, 0x0ULL);
568  case 98:
569  return jjMoveStringLiteralDfa1_0(0xf800000ULL, 0x0ULL, 0x0ULL);
570  case 99:
571  return jjMoveStringLiteralDfa1_0(0x3f0000000ULL, 0x0ULL, 0x0ULL);
572  case 100:
573  return jjMoveStringLiteralDfa1_0(0x1c00000000ULL, 0x0ULL, 0x0ULL);
574  case 101:
575  return jjMoveStringLiteralDfa1_0(0x3e000000000ULL, 0x0ULL, 0x0ULL);
576  case 102:
577  return jjMoveStringLiteralDfa1_0(0x7c0000000000ULL, 0x0ULL, 0x0ULL);
578  case 103:
579  return jjMoveStringLiteralDfa1_0(0x7800000000000ULL, 0x0ULL, 0x0ULL);
580  case 105:
581  return jjMoveStringLiteralDfa1_0(0x1f8000000000000ULL, 0x0ULL, 0x0ULL);
582  case 108:
583  return jjMoveStringLiteralDfa1_0(0x3e00000000000000ULL, 0x0ULL, 0x0ULL);
584  case 109:
585  return jjMoveStringLiteralDfa1_0(0xc000000000000000ULL, 0x0ULL, 0x0ULL);
586  case 110:
587  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3fULL, 0x0ULL);
588  case 111:
589  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xfc0ULL, 0x0ULL);
590  case 112:
591  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ff000ULL, 0x0ULL);
592  case 114:
593  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x1ffe00000ULL, 0x0ULL);
594  case 115:
595  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xffe00000000ULL, 0x0ULL);
596  case 116:
597  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000ULL, 0x0ULL);
598  case 117:
599  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf000000000000ULL, 0x0ULL);
600  case 118:
601  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf0000000000000ULL, 0x0ULL);
602  case 119:
603  return jjMoveStringLiteralDfa1_0(0x0ULL, 0xf00000000000000ULL, 0x0ULL);
604  case 120:
605  return jjMoveStringLiteralDfa1_0(0x0ULL, 0x3000000000000000ULL, 0x0ULL);
606  case 123:
607  jjmatchedKind = 163;
608  return jjMoveNfa_0(11, 0);
609  case 124:
610  jjmatchedKind = 156;
611  return jjMoveNfa_0(11, 0);
612  case 125:
613  jjmatchedKind = 164;
614  return jjMoveNfa_0(11, 0);
615  default :
616  return jjMoveNfa_0(11, 0);
617  }
618 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa1_0
int jjMoveStringLiteralDfa1_0(unsigned long long active0, unsigned long long active1, unsigned long long active2)
Definition: VhdlParserTokenManager.cc:620
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa10_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2453 of file VhdlParserTokenManager.cc.

2453  {
2454  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2455  return jjMoveNfa_0(11, 9);
2456  if (input_stream->endOfInput()) {
2457  return jjMoveNfa_0(11, 9);
2458  }
2459  curChar = input_stream->readChar();
2460  switch(curChar)
2461  {
2462  case 73:
2463  return jjMoveStringLiteralDfa11_0(active0, 0x40000000ULL, active1, 0L);
2464  case 82:
2465  return jjMoveStringLiteralDfa11_0(active0, 0x220000ULL, active1, 0L);
2466  case 85:
2467  return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x8000000ULL);
2468  case 105:
2469  return jjMoveStringLiteralDfa11_0(active0, 0x40000000ULL, active1, 0L);
2470  case 114:
2471  return jjMoveStringLiteralDfa11_0(active0, 0x220000ULL, active1, 0L);
2472  case 117:
2473  return jjMoveStringLiteralDfa11_0(active0, 0L, active1, 0x8000000ULL);
2474  default :
2475  break;
2476  }
2477  return jjMoveNfa_0(11, 10);
2478 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa11_0
int jjMoveStringLiteralDfa11_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2480
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa11_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2480 of file VhdlParserTokenManager.cc.

2480  {
2481  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2482  return jjMoveNfa_0(11, 10);
2483  if (input_stream->endOfInput()) {
2484  return jjMoveNfa_0(11, 10);
2485  }
2486  curChar = input_stream->readChar();
2487  switch(curChar)
2488  {
2489  case 65:
2490  return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x8000000ULL);
2491  case 69:
2492  if ((active0 & 0x20000ULL) != 0L)
2493  {
2494  jjmatchedKind = 17;
2495  jjmatchedPos = 11;
2496  }
2497  return jjMoveStringLiteralDfa12_0(active0, 0x200000ULL, active1, 0L);
2498  case 79:
2499  return jjMoveStringLiteralDfa12_0(active0, 0x40000000ULL, active1, 0L);
2500  case 97:
2501  return jjMoveStringLiteralDfa12_0(active0, 0L, active1, 0x8000000ULL);
2502  case 101:
2503  if ((active0 & 0x20000ULL) != 0L)
2504  {
2505  jjmatchedKind = 17;
2506  jjmatchedPos = 11;
2507  }
2508  return jjMoveStringLiteralDfa12_0(active0, 0x200000ULL, active1, 0L);
2509  case 111:
2510  return jjMoveStringLiteralDfa12_0(active0, 0x40000000ULL, active1, 0L);
2511  default :
2512  break;
2513  }
2514  return jjMoveNfa_0(11, 11);
2515 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa12_0
int jjMoveStringLiteralDfa12_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2517
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa12_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2517 of file VhdlParserTokenManager.cc.

2517  {
2518  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2519  return jjMoveNfa_0(11, 11);
2520  if (input_stream->endOfInput()) {
2521  return jjMoveNfa_0(11, 11);
2522  }
2523  curChar = input_stream->readChar();
2524  switch(curChar)
2525  {
2526  case 78:
2527  if ((active0 & 0x40000000ULL) != 0L)
2528  {
2529  jjmatchedKind = 30;
2530  jjmatchedPos = 12;
2531  }
2532  return jjMoveStringLiteralDfa13_0(active0, 0x200000ULL, active1, 0L);
2533  case 82:
2534  return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x8000000ULL);
2535  case 110:
2536  if ((active0 & 0x40000000ULL) != 0L)
2537  {
2538  jjmatchedKind = 30;
2539  jjmatchedPos = 12;
2540  }
2541  return jjMoveStringLiteralDfa13_0(active0, 0x200000ULL, active1, 0L);
2542  case 114:
2543  return jjMoveStringLiteralDfa13_0(active0, 0L, active1, 0x8000000ULL);
2544  default :
2545  break;
2546  }
2547  return jjMoveNfa_0(11, 12);
2548 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa13_0
int jjMoveStringLiteralDfa13_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2550
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa13_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2550 of file VhdlParserTokenManager.cc.

2550  {
2551  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2552  return jjMoveNfa_0(11, 12);
2553  if (input_stream->endOfInput()) {
2554  return jjMoveNfa_0(11, 12);
2555  }
2556  curChar = input_stream->readChar();
2557  switch(curChar)
2558  {
2559  case 65:
2560  return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x8000000ULL);
2561  case 84:
2562  return jjMoveStringLiteralDfa14_0(active0, 0x200000ULL, active1, 0L);
2563  case 97:
2564  return jjMoveStringLiteralDfa14_0(active0, 0L, active1, 0x8000000ULL);
2565  case 116:
2566  return jjMoveStringLiteralDfa14_0(active0, 0x200000ULL, active1, 0L);
2567  default :
2568  break;
2569  }
2570  return jjMoveNfa_0(11, 13);
2571 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa14_0
int jjMoveStringLiteralDfa14_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2573
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa14_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2573 of file VhdlParserTokenManager.cc.

2573  {
2574  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2575  return jjMoveNfa_0(11, 13);
2576  if (input_stream->endOfInput()) {
2577  return jjMoveNfa_0(11, 13);
2578  }
2579  curChar = input_stream->readChar();
2580  switch(curChar)
2581  {
2582  case 69:
2583  return jjMoveStringLiteralDfa15_0(active0, 0x200000ULL, active1, 0L);
2584  case 78:
2585  return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x8000000ULL);
2586  case 101:
2587  return jjMoveStringLiteralDfa15_0(active0, 0x200000ULL, active1, 0L);
2588  case 110:
2589  return jjMoveStringLiteralDfa15_0(active0, 0L, active1, 0x8000000ULL);
2590  default :
2591  break;
2592  }
2593  return jjMoveNfa_0(11, 14);
2594 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa15_0
int jjMoveStringLiteralDfa15_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2596
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa15_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2596 of file VhdlParserTokenManager.cc.

2596  {
2597  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2598  return jjMoveNfa_0(11, 14);
2599  if (input_stream->endOfInput()) {
2600  return jjMoveNfa_0(11, 14);
2601  }
2602  curChar = input_stream->readChar();
2603  switch(curChar)
2604  {
2605  case 69:
2606  if ((active0 & 0x200000ULL) != 0L)
2607  {
2608  jjmatchedKind = 21;
2609  jjmatchedPos = 15;
2610  }
2611  break;
2612  case 84:
2613  return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x8000000ULL);
2614  case 101:
2615  if ((active0 & 0x200000ULL) != 0L)
2616  {
2617  jjmatchedKind = 21;
2618  jjmatchedPos = 15;
2619  }
2620  break;
2621  case 116:
2622  return jjMoveStringLiteralDfa16_0(active0, 0L, active1, 0x8000000ULL);
2623  default :
2624  break;
2625  }
2626  return jjMoveNfa_0(11, 15);
2627 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa16_0
int jjMoveStringLiteralDfa16_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2629
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa16_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2629 of file VhdlParserTokenManager.cc.

2629  {
2630  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2631  return jjMoveNfa_0(11, 15);
2632  if (input_stream->endOfInput()) {
2633  return jjMoveNfa_0(11, 15);
2634  }
2635  curChar = input_stream->readChar();
2636  switch(curChar)
2637  {
2638  case 69:
2639  return jjMoveStringLiteralDfa17_0(active1, 0x8000000ULL);
2640  case 101:
2641  return jjMoveStringLiteralDfa17_0(active1, 0x8000000ULL);
2642  default :
2643  break;
2644  }
2645  return jjMoveNfa_0(11, 16);
2646 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa17_0
int jjMoveStringLiteralDfa17_0(unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2648
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa17_0 ( unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2648 of file VhdlParserTokenManager.cc.

2648  {
2649  if (((active1 &= old1)) == 0L)
2650  return jjMoveNfa_0(11, 16);
2651  if (input_stream->endOfInput()) {
2652  return jjMoveNfa_0(11, 16);
2653  }
2654  curChar = input_stream->readChar();
2655  switch(curChar)
2656  {
2657  case 69:
2658  if ((active1 & 0x8000000ULL) != 0L)
2659  {
2660  jjmatchedKind = 91;
2661  jjmatchedPos = 17;
2662  }
2663  break;
2664  case 101:
2665  if ((active1 & 0x8000000ULL) != 0L)
2666  {
2667  jjmatchedKind = 91;
2668  jjmatchedPos = 17;
2669  }
2670  break;
2671  default :
2672  break;
2673  }
2674  return jjMoveNfa_0(11, 17);
2675 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa1_0 ( unsigned long long  active0,
unsigned long long  active1,
unsigned long long  active2 
)

Definition at line 620 of file VhdlParserTokenManager.cc.

620  {
621  if (input_stream->endOfInput()) {
622  return jjMoveNfa_0(11, 0);
623  }
624  curChar = input_stream->readChar();
625  switch(curChar)
626  {
627  case 42:
628  if ((active2 & 0x4ULL) != 0L)
629  {
630  jjmatchedKind = 130;
631  jjmatchedPos = 1;
632  }
633  break;
634  case 47:
635  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x4000000ULL);
636  case 60:
637  if ((active2 & 0x40000ULL) != 0L)
638  {
639  jjmatchedKind = 146;
640  jjmatchedPos = 1;
641  }
642  else if ((active2 & 0x1000000ULL) != 0L)
643  {
644  jjmatchedKind = 152;
645  jjmatchedPos = 1;
646  }
647  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x400000ULL);
648  case 61:
649  if ((active2 & 0x80ULL) != 0L)
650  {
651  jjmatchedKind = 135;
652  jjmatchedPos = 1;
653  }
654  else if ((active2 & 0x400ULL) != 0L)
655  {
656  jjmatchedKind = 138;
657  jjmatchedPos = 1;
658  }
659  else if ((active2 & 0x800ULL) != 0L)
660  {
661  jjmatchedKind = 139;
662  jjmatchedPos = 1;
663  }
664  else if ((active2 & 0x8000ULL) != 0L)
665  {
666  jjmatchedKind = 143;
667  jjmatchedPos = 1;
668  }
669  else if ((active2 & 0x2000000ULL) != 0L)
670  {
671  jjmatchedKind = 153;
672  jjmatchedPos = 1;
673  }
674  break;
675  case 62:
676  if ((active2 & 0x10000ULL) != 0L)
677  {
678  jjmatchedKind = 144;
679  jjmatchedPos = 1;
680  }
681  else if ((active2 & 0x20000ULL) != 0L)
682  {
683  jjmatchedKind = 145;
684  jjmatchedPos = 1;
685  }
686  else if ((active2 & 0x80000ULL) != 0L)
687  {
688  jjmatchedKind = 147;
689  jjmatchedPos = 1;
690  }
691  else if ((active2 & 0x800000ULL) != 0L)
692  {
693  jjmatchedKind = 151;
694  jjmatchedPos = 1;
695  }
696  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0L, active2, 0x200000ULL);
697  case 63:
698  if ((active2 & 0x100000ULL) != 0L)
699  {
700  jjmatchedKind = 148;
701  jjmatchedPos = 1;
702  }
703  break;
704  case 65:
705  return jjMoveStringLiteralDfa2_0(active0, 0x4200040020000000ULL, active1, 0x110000000203001ULL, active2, 0L);
706  case 66:
707  return jjMoveStringLiteralDfa2_0(active0, 0x800ULL, active1, 0L, active2, 0L);
708  case 67:
709  return jjMoveStringLiteralDfa2_0(active0, 0x1000ULL, active1, 0L, active2, 0L);
710  case 69:
711  return jjMoveStringLiteralDfa2_0(active0, 0x1800400800000ULL, active1, 0xf3fc00006ULL, active2, 0L);
712  case 70:
713  if ((active0 & 0x8000000000000ULL) != 0L)
714  {
715  jjmatchedKind = 51;
716  jjmatchedPos = 1;
717  }
718  else if ((active1 & 0x40ULL) != 0L)
719  {
720  jjmatchedKind = 70;
721  jjmatchedPos = 1;
722  }
723  return jjMoveStringLiteralDfa2_0(active0, 0x2000ULL, active1, 0L, active2, 0L);
724  case 72:
725  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x600102000000000ULL, active2, 0L);
726  case 73:
727  return jjMoveStringLiteralDfa2_0(active0, 0x1c00080800000000ULL, active1, 0x800001000000000ULL, active2, 0L);
728  case 76:
729  return jjMoveStringLiteralDfa2_0(active0, 0x600100c000ULL, active1, 0xc000000000ULL, active2, 0L);
730  case 77:
731  return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0x20000000000000ULL, active2, 0L);
732  case 78:
733  if ((active0 & 0x20000000000000ULL) != 0L)
734  {
735  jjmatchedKind = 53;
736  jjmatchedPos = 1;
737  }
738  else if ((active1 & 0x80ULL) != 0L)
739  {
740  jjmatchedKind = 71;
741  jjmatchedPos = 1;
742  }
743  return jjMoveStringLiteralDfa2_0(active0, 0xc0018000010000ULL, active1, 0x2007000000000000ULL, active2, 0L);
744  case 79:
745  if ((active1 & 0x200000000000ULL) != 0L)
746  {
747  jjmatchedKind = 109;
748  jjmatchedPos = 1;
749  }
750  return jjMoveStringLiteralDfa2_0(active0, 0xa0003013d2000000ULL, active1, 0x10000000c000c018ULL, active2, 0L);
751  case 80:
752  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000100ULL, active2, 0L);
753  case 82:
754  if ((active1 & 0x200ULL) != 0L)
755  {
756  jjmatchedKind = 73;
757  jjmatchedPos = 1;
758  }
759  return jjMoveStringLiteralDfa2_0(active0, 0x2000000060000ULL, active1, 0x4300000f0000ULL, active2, 0L);
760  case 83:
761  if ((active0 & 0x100000000000000ULL) != 0L)
762  {
763  jjmatchedKind = 56;
764  jjmatchedPos = 1;
765  }
766  return jjMoveStringLiteralDfa2_0(active0, 0x380000ULL, active1, 0x8000000000000ULL, active2, 0L);
767  case 84:
768  return jjMoveStringLiteralDfa2_0(active0, 0x400000ULL, active1, 0x40000000400ULL, active2, 0L);
769  case 85:
770  return jjMoveStringLiteralDfa2_0(active0, 0x440000c000000ULL, active1, 0x80080000100820ULL, active2, 0L);
771  case 88:
772  return jjMoveStringLiteralDfa2_0(active0, 0x20000000000ULL, active1, 0L, active2, 0L);
773  case 89:
774  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000ULL, active2, 0L);
775  case 97:
776  return jjMoveStringLiteralDfa2_0(active0, 0x4200040020000000ULL, active1, 0x110000000203001ULL, active2, 0L);
777  case 98:
778  return jjMoveStringLiteralDfa2_0(active0, 0x800ULL, active1, 0L, active2, 0L);
779  case 99:
780  return jjMoveStringLiteralDfa2_0(active0, 0x1000ULL, active1, 0L, active2, 0L);
781  case 101:
782  return jjMoveStringLiteralDfa2_0(active0, 0x1800400800000ULL, active1, 0xf3fc00006ULL, active2, 0L);
783  case 102:
784  if ((active0 & 0x8000000000000ULL) != 0L)
785  {
786  jjmatchedKind = 51;
787  jjmatchedPos = 1;
788  }
789  else if ((active1 & 0x40ULL) != 0L)
790  {
791  jjmatchedKind = 70;
792  jjmatchedPos = 1;
793  }
794  return jjMoveStringLiteralDfa2_0(active0, 0x2000ULL, active1, 0L, active2, 0L);
795  case 104:
796  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x600102000000000ULL, active2, 0L);
797  case 105:
798  return jjMoveStringLiteralDfa2_0(active0, 0x1c00080800000000ULL, active1, 0x800001000000000ULL, active2, 0L);
799  case 108:
800  return jjMoveStringLiteralDfa2_0(active0, 0x600100c000ULL, active1, 0xc000000000ULL, active2, 0L);
801  case 109:
802  return jjMoveStringLiteralDfa2_0(active0, 0x10000000000000ULL, active1, 0x20000000000000ULL, active2, 0L);
803  case 110:
804  if ((active0 & 0x20000000000000ULL) != 0L)
805  {
806  jjmatchedKind = 53;
807  jjmatchedPos = 1;
808  }
809  else if ((active1 & 0x80ULL) != 0L)
810  {
811  jjmatchedKind = 71;
812  jjmatchedPos = 1;
813  }
814  return jjMoveStringLiteralDfa2_0(active0, 0xc0018000010000ULL, active1, 0x2007000000000000ULL, active2, 0L);
815  case 111:
816  if ((active1 & 0x200000000000ULL) != 0L)
817  {
818  jjmatchedKind = 109;
819  jjmatchedPos = 1;
820  }
821  return jjMoveStringLiteralDfa2_0(active0, 0xa0003013d2000000ULL, active1, 0x10000000c000c018ULL, active2, 0L);
822  case 112:
823  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x40000000000100ULL, active2, 0L);
824  case 114:
825  if ((active1 & 0x200ULL) != 0L)
826  {
827  jjmatchedKind = 73;
828  jjmatchedPos = 1;
829  }
830  return jjMoveStringLiteralDfa2_0(active0, 0x2000000060000ULL, active1, 0x4300000f0000ULL, active2, 0L);
831  case 115:
832  if ((active0 & 0x100000000000000ULL) != 0L)
833  {
834  jjmatchedKind = 56;
835  jjmatchedPos = 1;
836  }
837  return jjMoveStringLiteralDfa2_0(active0, 0x380000ULL, active1, 0x8000000000000ULL, active2, 0L);
838  case 116:
839  return jjMoveStringLiteralDfa2_0(active0, 0x400000ULL, active1, 0x40000000400ULL, active2, 0L);
840  case 117:
841  return jjMoveStringLiteralDfa2_0(active0, 0x440000c000000ULL, active1, 0x80080000100820ULL, active2, 0L);
842  case 120:
843  return jjMoveStringLiteralDfa2_0(active0, 0x20000000000ULL, active1, 0L, active2, 0L);
844  case 121:
845  return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x800000000000ULL, active2, 0L);
846  default :
847  break;
848  }
849  return jjMoveNfa_0(11, 1);
850 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa2_0
int jjMoveStringLiteralDfa2_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2)
Definition: VhdlParserTokenManager.cc:852
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa2_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1,
unsigned long long  old2,
unsigned long long  active2 
)

Definition at line 852 of file VhdlParserTokenManager.cc.

852  {
853  if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
854  return jjMoveNfa_0(11, 1);
855  if (input_stream->endOfInput()) {
856  return jjMoveNfa_0(11, 1);
857  }
858  curChar = input_stream->readChar();
859  switch(curChar)
860  {
861  case 61:
862  if ((active2 & 0x200000ULL) != 0L)
863  {
864  jjmatchedKind = 149;
865  jjmatchedPos = 2;
866  }
867  else if ((active2 & 0x400000ULL) != 0L)
868  {
869  jjmatchedKind = 150;
870  jjmatchedPos = 2;
871  }
872  else if ((active2 & 0x4000000ULL) != 0L)
873  {
874  jjmatchedKind = 154;
875  jjmatchedPos = 2;
876  }
877  break;
878  case 65:
879  if ((active1 & 0x4000000000ULL) != 0L)
880  {
881  jjmatchedKind = 102;
882  jjmatchedPos = 2;
883  }
884  else if ((active1 & 0x10000000000ULL) != 0L)
885  {
886  jjmatchedKind = 104;
887  jjmatchedPos = 2;
888  }
889  return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000ULL, active1, 0x1402000000000ULL, active2, 0L);
890  case 66:
891  return jjMoveStringLiteralDfa3_0(active0, 0x600000000000000ULL, active1, 0x80000000000ULL, active2, 0L);
892  case 67:
893  return jjMoveStringLiteralDfa3_0(active0, 0x21000ULL, active1, 0x401000ULL, active2, 0L);
894  case 68:
895  if ((active0 & 0x10000ULL) != 0L)
896  {
897  jjmatchedKind = 16;
898  jjmatchedPos = 2;
899  }
900  else if ((active0 & 0x8000000000ULL) != 0L)
901  {
902  jjmatchedKind = 39;
903  jjmatchedPos = 2;
904  }
905  else if ((active0 & 0x8000000000000000ULL) != 0L)
906  {
907  jjmatchedKind = 63;
908  jjmatchedPos = 2;
909  }
910  return jjMoveStringLiteralDfa3_0(active0, 0x2000000ULL, active1, 0L, active2, 0L);
911  case 69:
912  if ((active1 & 0x8000000000000ULL) != 0L)
913  {
914  jjmatchedKind = 115;
915  jjmatchedPos = 2;
916  }
917  return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000ULL, active1, 0x200100000000100ULL, active2, 0L);
918  case 70:
919  return jjMoveStringLiteralDfa3_0(active0, 0x404000000ULL, active1, 0L, active2, 0L);
920  case 71:
921  return jjMoveStringLiteralDfa3_0(active0, 0x800000ULL, active1, 0x1000800000ULL, active2, 0L);
922  case 72:
923  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400ULL, active2, 0L);
924  case 73:
925  return jjMoveStringLiteralDfa3_0(active0, 0x60000004000ULL, active1, 0x502000000000000ULL, active2, 0L);
926  case 74:
927  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000000ULL, active2, 0L);
928  case 76:
929  if ((active0 & 0x8000ULL) != 0L)
930  {
931  jjmatchedKind = 15;
932  jjmatchedPos = 2;
933  }
934  else if ((active1 & 0x40000000ULL) != 0L)
935  {
936  jjmatchedKind = 94;
937  jjmatchedPos = 2;
938  }
939  else if ((active1 & 0x8000000000ULL) != 0L)
940  {
941  jjmatchedKind = 103;
942  jjmatchedPos = 2;
943  }
944  else if ((active1 & 0x20000000000ULL) != 0L)
945  {
946  jjmatchedKind = 105;
947  jjmatchedPos = 2;
948  }
949  return jjMoveStringLiteralDfa3_0(active0, 0x80000000000ULL, active1, 0x202000020ULL, active2, 0L);
950  case 77:
951  if ((active1 & 0x10000000ULL) != 0L)
952  {
953  jjmatchedKind = 92;
954  jjmatchedPos = 2;
955  }
956  return jjMoveStringLiteralDfa3_0(active0, 0x10000000ULL, active1, 0L, active2, 0L);
957  case 78:
958  return jjMoveStringLiteralDfa3_0(active0, 0x801c001c0000000ULL, active1, 0x80000000200001ULL, active2, 0L);
959  case 79:
960  return jjMoveStringLiteralDfa3_0(active0, 0x2082000001000000ULL, active1, 0x20200000000f0000ULL, active2, 0L);
961  case 80:
962  if ((active0 & 0x4000000000000000ULL) != 0L)
963  {
964  jjmatchedKind = 62;
965  jjmatchedPos = 2;
966  }
967  return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000ULL, active1, 0x800020000000ULL, active2, 0L);
968  case 81:
969  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000ULL, active2, 0L);
970  case 82:
971  if ((active0 & 0x100000000000ULL) != 0L)
972  {
973  jjmatchedKind = 44;
974  jjmatchedPos = 2;
975  }
976  else if ((active1 & 0x8ULL) != 0L)
977  {
978  jjmatchedKind = 67;
979  jjmatchedPos = 2;
980  }
981  else if ((active1 & 0x80000000ULL) != 0L)
982  {
983  jjmatchedKind = 95;
984  jjmatchedPos = 2;
985  }
986  else if ((active1 & 0x1000000000000000ULL) != 0L)
987  {
988  jjmatchedKind = 124;
989  jjmatchedPos = 2;
990  }
991  return jjMoveStringLiteralDfa3_0(active0, 0x200000040000ULL, active1, 0x50040000106000ULL, active2, 0L);
992  case 83:
993  if ((active0 & 0x800ULL) != 0L)
994  {
995  jjmatchedKind = 11;
996  jjmatchedPos = 2;
997  }
998  else if ((active0 & 0x8000000ULL) != 0L)
999  {
1000  jjmatchedKind = 27;
1001  jjmatchedPos = 2;
1002  }
1003  return jjMoveStringLiteralDfa3_0(active0, 0x6820380000ULL, active1, 0xc008000ULL, active2, 0L);
1004  case 84:
1005  if ((active1 & 0x10ULL) != 0L)
1006  {
1007  jjmatchedKind = 68;
1008  jjmatchedPos = 2;
1009  }
1010  else if ((active1 & 0x800ULL) != 0L)
1011  {
1012  jjmatchedKind = 75;
1013  jjmatchedPos = 2;
1014  }
1015  return jjMoveStringLiteralDfa3_0(active0, 0x1000010000402000ULL, active1, 0x804000100000000ULL, active2, 0L);
1016  case 86:
1017  return jjMoveStringLiteralDfa3_0(active0, 0x200000000ULL, active1, 0x800000000ULL, active2, 0L);
1018  case 87:
1019  if ((active1 & 0x2ULL) != 0L)
1020  {
1021  jjmatchedKind = 65;
1022  jjmatchedPos = 2;
1023  }
1024  return jjMoveStringLiteralDfa3_0(active0, 0x1000000000ULL, active1, 0L, active2, 0L);
1025  case 88:
1026  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4ULL, active2, 0L);
1027  case 97:
1028  if ((active1 & 0x4000000000ULL) != 0L)
1029  {
1030  jjmatchedKind = 102;
1031  jjmatchedPos = 2;
1032  }
1033  else if ((active1 & 0x10000000000ULL) != 0L)
1034  {
1035  jjmatchedKind = 104;
1036  jjmatchedPos = 2;
1037  }
1038  return jjMoveStringLiteralDfa3_0(active0, 0x4000000000000ULL, active1, 0x1402000000000ULL, active2, 0L);
1039  case 98:
1040  return jjMoveStringLiteralDfa3_0(active0, 0x600000000000000ULL, active1, 0x80000000000ULL, active2, 0L);
1041  case 99:
1042  return jjMoveStringLiteralDfa3_0(active0, 0x21000ULL, active1, 0x401000ULL, active2, 0L);
1043  case 100:
1044  if ((active0 & 0x10000ULL) != 0L)
1045  {
1046  jjmatchedKind = 16;
1047  jjmatchedPos = 2;
1048  }
1049  else if ((active0 & 0x8000000000ULL) != 0L)
1050  {
1051  jjmatchedKind = 39;
1052  jjmatchedPos = 2;
1053  }
1054  else if ((active0 & 0x8000000000000000ULL) != 0L)
1055  {
1056  jjmatchedKind = 63;
1057  jjmatchedPos = 2;
1058  }
1059  return jjMoveStringLiteralDfa3_0(active0, 0x2000000ULL, active1, 0L, active2, 0L);
1060  case 101:
1061  if ((active1 & 0x8000000000000ULL) != 0L)
1062  {
1063  jjmatchedKind = 115;
1064  jjmatchedPos = 2;
1065  }
1066  return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000ULL, active1, 0x200100000000100ULL, active2, 0L);
1067  case 102:
1068  return jjMoveStringLiteralDfa3_0(active0, 0x404000000ULL, active1, 0L, active2, 0L);
1069  case 103:
1070  return jjMoveStringLiteralDfa3_0(active0, 0x800000ULL, active1, 0x1000800000ULL, active2, 0L);
1071  case 104:
1072  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400ULL, active2, 0L);
1073  case 105:
1074  return jjMoveStringLiteralDfa3_0(active0, 0x60000004000ULL, active1, 0x502000000000000ULL, active2, 0L);
1075  case 106:
1076  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x1000000ULL, active2, 0L);
1077  case 108:
1078  if ((active0 & 0x8000ULL) != 0L)
1079  {
1080  jjmatchedKind = 15;
1081  jjmatchedPos = 2;
1082  }
1083  else if ((active1 & 0x40000000ULL) != 0L)
1084  {
1085  jjmatchedKind = 94;
1086  jjmatchedPos = 2;
1087  }
1088  else if ((active1 & 0x8000000000ULL) != 0L)
1089  {
1090  jjmatchedKind = 103;
1091  jjmatchedPos = 2;
1092  }
1093  else if ((active1 & 0x20000000000ULL) != 0L)
1094  {
1095  jjmatchedKind = 105;
1096  jjmatchedPos = 2;
1097  }
1098  return jjMoveStringLiteralDfa3_0(active0, 0x80000000000ULL, active1, 0x202000020ULL, active2, 0L);
1099  case 109:
1100  if ((active1 & 0x10000000ULL) != 0L)
1101  {
1102  jjmatchedKind = 92;
1103  jjmatchedPos = 2;
1104  }
1105  return jjMoveStringLiteralDfa3_0(active0, 0x10000000ULL, active1, 0L, active2, 0L);
1106  case 110:
1107  return jjMoveStringLiteralDfa3_0(active0, 0x801c001c0000000ULL, active1, 0x80000000200001ULL, active2, 0L);
1108  case 111:
1109  return jjMoveStringLiteralDfa3_0(active0, 0x2082000001000000ULL, active1, 0x20200000000f0000ULL, active2, 0L);
1110  case 112:
1111  if ((active0 & 0x4000000000000000ULL) != 0L)
1112  {
1113  jjmatchedKind = 62;
1114  jjmatchedPos = 2;
1115  }
1116  return jjMoveStringLiteralDfa3_0(active0, 0x10000000000000ULL, active1, 0x800020000000ULL, active2, 0L);
1117  case 113:
1118  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x400000000ULL, active2, 0L);
1119  case 114:
1120  if ((active0 & 0x100000000000ULL) != 0L)
1121  {
1122  jjmatchedKind = 44;
1123  jjmatchedPos = 2;
1124  }
1125  else if ((active1 & 0x8ULL) != 0L)
1126  {
1127  jjmatchedKind = 67;
1128  jjmatchedPos = 2;
1129  }
1130  else if ((active1 & 0x80000000ULL) != 0L)
1131  {
1132  jjmatchedKind = 95;
1133  jjmatchedPos = 2;
1134  }
1135  else if ((active1 & 0x1000000000000000ULL) != 0L)
1136  {
1137  jjmatchedKind = 124;
1138  jjmatchedPos = 2;
1139  }
1140  return jjMoveStringLiteralDfa3_0(active0, 0x200000040000ULL, active1, 0x50040000106000ULL, active2, 0L);
1141  case 115:
1142  if ((active0 & 0x800ULL) != 0L)
1143  {
1144  jjmatchedKind = 11;
1145  jjmatchedPos = 2;
1146  }
1147  else if ((active0 & 0x8000000ULL) != 0L)
1148  {
1149  jjmatchedKind = 27;
1150  jjmatchedPos = 2;
1151  }
1152  return jjMoveStringLiteralDfa3_0(active0, 0x6820380000ULL, active1, 0xc008000ULL, active2, 0L);
1153  case 116:
1154  if ((active1 & 0x10ULL) != 0L)
1155  {
1156  jjmatchedKind = 68;
1157  jjmatchedPos = 2;
1158  }
1159  else if ((active1 & 0x800ULL) != 0L)
1160  {
1161  jjmatchedKind = 75;
1162  jjmatchedPos = 2;
1163  }
1164  return jjMoveStringLiteralDfa3_0(active0, 0x1000010000402000ULL, active1, 0x804000100000000ULL, active2, 0L);
1165  case 118:
1166  return jjMoveStringLiteralDfa3_0(active0, 0x200000000ULL, active1, 0x800000000ULL, active2, 0L);
1167  case 119:
1168  if ((active1 & 0x2ULL) != 0L)
1169  {
1170  jjmatchedKind = 65;
1171  jjmatchedPos = 2;
1172  }
1173  return jjMoveStringLiteralDfa3_0(active0, 0x1000000000ULL, active1, 0L, active2, 0L);
1174  case 120:
1175  return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x4ULL, active2, 0L);
1176  default :
1177  break;
1178  }
1179  return jjMoveNfa_0(11, 2);
1180 }
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa3_0
int jjMoveStringLiteralDfa3_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1, unsigned long long old2, unsigned long long active2)
Definition: VhdlParserTokenManager.cc:1182
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa3_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1,
unsigned long long  old2,
unsigned long long  active2 
)

Definition at line 1182 of file VhdlParserTokenManager.cc.

1182  {
1183  if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
1184  return jjMoveNfa_0(11, 2);
1185  if (input_stream->endOfInput()) {
1186  return jjMoveNfa_0(11, 2);
1187  }
1188  curChar = input_stream->readChar();
1189  switch(curChar)
1190  {
1191  case 65:
1192  return jjMoveStringLiteralDfa4_0(active0, 0x400044000ULL, active1, 0x2000ULL);
1193  case 67:
1194  return jjMoveStringLiteralDfa4_0(active0, 0x600801000000ULL, active1, 0x30000ULL);
1195  case 68:
1196  if ((active1 & 0x1ULL) != 0L)
1197  {
1198  jjmatchedKind = 64;
1199  jjmatchedPos = 3;
1200  }
1201  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20000000000000ULL);
1202  case 69:
1203  if ((active0 & 0x20000000ULL) != 0L)
1204  {
1205  jjmatchedKind = 29;
1206  jjmatchedPos = 3;
1207  }
1208  else if ((active0 & 0x2000000000ULL) != 0L)
1209  {
1210  jjmatchedKind = 37;
1211  jjmatchedPos = 3;
1212  }
1213  else if ((active0 & 0x80000000000ULL) != 0L)
1214  {
1215  jjmatchedKind = 43;
1216  jjmatchedPos = 3;
1217  }
1218  else if ((active1 & 0x100000ULL) != 0L)
1219  {
1220  jjmatchedKind = 84;
1221  jjmatchedPos = 3;
1222  }
1223  else if ((active1 & 0x800000000000ULL) != 0L)
1224  {
1225  jjmatchedKind = 111;
1226  jjmatchedPos = 3;
1227  }
1228  return jjMoveStringLiteralDfa4_0(active0, 0x1201800200083000ULL, active1, 0xa03000400ULL);
1229  case 70:
1230  return jjMoveStringLiteralDfa4_0(active0, 0x44000000ULL, active1, 0x1000000000000ULL);
1231  case 71:
1232  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000ULL);
1233  case 72:
1234  if ((active1 & 0x800000000000000ULL) != 0L)
1235  {
1236  jjmatchedKind = 123;
1237  jjmatchedPos = 3;
1238  }
1239  return jjMoveStringLiteralDfa4_0(active0, 0x20000ULL, active1, 0L);
1240  case 73:
1241  return jjMoveStringLiteralDfa4_0(active0, 0x14000800000ULL, active1, 0x94000000800000ULL);
1242  case 75:
1243  return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000ULL, active1, 0x1000ULL);
1244  case 76:
1245  if ((active1 & 0x20ULL) != 0L)
1246  {
1247  jjmatchedKind = 69;
1248  jjmatchedPos = 3;
1249  }
1250  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400000000000000ULL);
1251  case 78:
1252  if ((active1 & 0x100ULL) != 0L)
1253  {
1254  jjmatchedKind = 72;
1255  jjmatchedPos = 3;
1256  }
1257  else if ((active1 & 0x100000000000ULL) != 0L)
1258  {
1259  jjmatchedKind = 108;
1260  jjmatchedPos = 3;
1261  }
1262  else if ((active1 & 0x200000000000000ULL) != 0L)
1263  {
1264  jjmatchedKind = 121;
1265  jjmatchedPos = 3;
1266  }
1267  return jjMoveStringLiteralDfa4_0(active0, 0x1000000000ULL, active1, 0x401000000000ULL);
1268  case 79:
1269  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40040020400000ULL);
1270  case 80:
1271  if ((active0 & 0x2000000000000000ULL) != 0L)
1272  {
1273  jjmatchedKind = 61;
1274  jjmatchedPos = 3;
1275  }
1276  return jjMoveStringLiteralDfa4_0(active0, 0x10000000ULL, active1, 0x40000ULL);
1277  case 82:
1278  if ((active1 & 0x2000000000000000ULL) != 0L)
1279  {
1280  jjmatchedKind = 125;
1281  jjmatchedPos = 3;
1282  }
1283  return jjMoveStringLiteralDfa4_0(active0, 0x444040000400000ULL, active1, 0x2000000000ULL);
1284  case 83:
1285  return jjMoveStringLiteralDfa4_0(active0, 0x80000000ULL, active1, 0L);
1286  case 84:
1287  if ((active0 & 0x20000000000ULL) != 0L)
1288  {
1289  jjmatchedKind = 41;
1290  jjmatchedPos = 3;
1291  }
1292  else if ((active1 & 0x4ULL) != 0L)
1293  {
1294  jjmatchedKind = 66;
1295  jjmatchedPos = 3;
1296  }
1297  else if ((active1 & 0x4000ULL) != 0L)
1298  {
1299  jjmatchedKind = 78;
1300  jjmatchedPos = 3;
1301  }
1302  else if ((active1 & 0x100000000000000ULL) != 0L)
1303  {
1304  jjmatchedKind = 120;
1305  jjmatchedPos = 3;
1306  }
1307  return jjMoveStringLiteralDfa4_0(active0, 0x100000000ULL, active1, 0x208000c088000ULL);
1308  case 85:
1309  return jjMoveStringLiteralDfa4_0(active0, 0x92000000300000ULL, active1, 0x500000000ULL);
1310  case 89:
1311  if ((active0 & 0x2000000ULL) != 0L)
1312  {
1313  jjmatchedKind = 25;
1314  jjmatchedPos = 3;
1315  }
1316  break;
1317  case 97:
1318  return jjMoveStringLiteralDfa4_0(active0, 0x400044000ULL, active1, 0x2000ULL);
1319  case 99:
1320  return jjMoveStringLiteralDfa4_0(active0, 0x600801000000ULL, active1, 0x30000ULL);
1321  case 100:
1322  if ((active1 & 0x1ULL) != 0L)
1323  {
1324  jjmatchedKind = 64;
1325  jjmatchedPos = 3;
1326  }
1327  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x20000000000000ULL);
1328  case 101:
1329  if ((active0 & 0x20000000ULL) != 0L)
1330  {
1331  jjmatchedKind = 29;
1332  jjmatchedPos = 3;
1333  }
1334  else if ((active0 & 0x2000000000ULL) != 0L)
1335  {
1336  jjmatchedKind = 37;
1337  jjmatchedPos = 3;
1338  }
1339  else if ((active0 & 0x80000000000ULL) != 0L)
1340  {
1341  jjmatchedKind = 43;
1342  jjmatchedPos = 3;
1343  }
1344  else if ((active1 & 0x100000ULL) != 0L)
1345  {
1346  jjmatchedKind = 84;
1347  jjmatchedPos = 3;
1348  }
1349  else if ((active1 & 0x800000000000ULL) != 0L)
1350  {
1351  jjmatchedKind = 111;
1352  jjmatchedPos = 3;
1353  }
1354  return jjMoveStringLiteralDfa4_0(active0, 0x1201800200083000ULL, active1, 0xa03000400ULL);
1355  case 102:
1356  return jjMoveStringLiteralDfa4_0(active0, 0x44000000ULL, active1, 0x1000000000000ULL);
1357  case 103:
1358  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x200000ULL);
1359  case 104:
1360  if ((active1 & 0x800000000000000ULL) != 0L)
1361  {
1362  jjmatchedKind = 123;
1363  jjmatchedPos = 3;
1364  }
1365  return jjMoveStringLiteralDfa4_0(active0, 0x20000ULL, active1, 0L);
1366  case 105:
1367  return jjMoveStringLiteralDfa4_0(active0, 0x14000800000ULL, active1, 0x94000000800000ULL);
1368  case 107:
1369  return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000ULL, active1, 0x1000ULL);
1370  case 108:
1371  if ((active1 & 0x20ULL) != 0L)
1372  {
1373  jjmatchedKind = 69;
1374  jjmatchedPos = 3;
1375  }
1376  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x400000000000000ULL);
1377  case 110:
1378  if ((active1 & 0x100ULL) != 0L)
1379  {
1380  jjmatchedKind = 72;
1381  jjmatchedPos = 3;
1382  }
1383  else if ((active1 & 0x100000000000ULL) != 0L)
1384  {
1385  jjmatchedKind = 108;
1386  jjmatchedPos = 3;
1387  }
1388  else if ((active1 & 0x200000000000000ULL) != 0L)
1389  {
1390  jjmatchedKind = 121;
1391  jjmatchedPos = 3;
1392  }
1393  return jjMoveStringLiteralDfa4_0(active0, 0x1000000000ULL, active1, 0x401000000000ULL);
1394  case 111:
1395  return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x40040020400000ULL);
1396  case 112:
1397  if ((active0 & 0x2000000000000000ULL) != 0L)
1398  {
1399  jjmatchedKind = 61;
1400  jjmatchedPos = 3;
1401  }
1402  return jjMoveStringLiteralDfa4_0(active0, 0x10000000ULL, active1, 0x40000ULL);
1403  case 114:
1404  if ((active1 & 0x2000000000000000ULL) != 0L)
1405  {
1406  jjmatchedKind = 125;
1407  jjmatchedPos = 3;
1408  }
1409  return jjMoveStringLiteralDfa4_0(active0, 0x444040000400000ULL, active1, 0x2000000000ULL);
1410  case 115:
1411  return jjMoveStringLiteralDfa4_0(active0, 0x80000000ULL, active1, 0L);
1412  case 116:
1413  if ((active0 & 0x20000000000ULL) != 0L)
1414  {
1415  jjmatchedKind = 41;
1416  jjmatchedPos = 3;
1417  }
1418  else if ((active1 & 0x4ULL) != 0L)
1419  {
1420  jjmatchedKind = 66;
1421  jjmatchedPos = 3;
1422  }
1423  else if ((active1 & 0x4000ULL) != 0L)
1424  {
1425  jjmatchedKind = 78;
1426  jjmatchedPos = 3;
1427  }
1428  else if ((active1 & 0x100000000000000ULL) != 0L)
1429  {
1430  jjmatchedKind = 120;
1431  jjmatchedPos = 3;
1432  }
1433  return jjMoveStringLiteralDfa4_0(active0, 0x100000000ULL, active1, 0x208000c088000ULL);
1434  case 117:
1435  return jjMoveStringLiteralDfa4_0(active0, 0x92000000300000ULL, active1, 0x500000000ULL);
1436  case 121:
1437  if ((active0 & 0x2000000ULL) != 0L)
1438  {
1439  jjmatchedKind = 25;
1440  jjmatchedPos = 3;
1441  }
1442  break;
1443  default :
1444  break;
1445  }
1446  return jjMoveNfa_0(11, 3);
1447 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa4_0
int jjMoveStringLiteralDfa4_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:1449
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa4_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 1449 of file VhdlParserTokenManager.cc.

1449  {
1450  if (((active0 &= old0) | (active1 &= old1)) == 0L)
1451  return jjMoveNfa_0(11, 3);
1452  if (input_stream->endOfInput()) {
1453  return jjMoveNfa_0(11, 3);
1454  }
1455  curChar = input_stream->readChar();
1456  switch(curChar)
1457  {
1458  case 65:
1459  return jjMoveStringLiteralDfa5_0(active0, 0xc00000000000000ULL, active1, 0x10001002001000ULL);
1460  case 67:
1461  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x201000000ULL);
1462  case 68:
1463  return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000ULL, active1, 0L);
1464  case 69:
1465  if ((active0 & 0x200000000000ULL) != 0L)
1466  {
1467  jjmatchedKind = 45;
1468  jjmatchedPos = 4;
1469  }
1470  else if ((active1 & 0x200000ULL) != 0L)
1471  {
1472  jjmatchedKind = 85;
1473  jjmatchedPos = 4;
1474  }
1475  else if ((active1 & 0x20000000000000ULL) != 0L)
1476  {
1477  jjmatchedKind = 117;
1478  jjmatchedPos = 4;
1479  }
1480  else if ((active1 & 0x400000000000000ULL) != 0L)
1481  {
1482  jjmatchedKind = 122;
1483  jjmatchedPos = 4;
1484  }
1485  return jjMoveStringLiteralDfa5_0(active0, 0x104000000ULL, active1, 0x24000f0000ULL);
1486  case 70:
1487  if ((active0 & 0x4000000000ULL) != 0L)
1488  {
1489  jjmatchedKind = 38;
1490  jjmatchedPos = 4;
1491  }
1492  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000ULL);
1493  case 73:
1494  return jjMoveStringLiteralDfa5_0(active0, 0x40420000ULL, active1, 0L);
1495  case 75:
1496  if ((active0 & 0x1000000ULL) != 0L)
1497  {
1498  jjmatchedKind = 24;
1499  jjmatchedPos = 4;
1500  }
1501  break;
1502  case 76:
1503  if ((active0 & 0x200000000000000ULL) != 0L)
1504  {
1505  jjmatchedKind = 57;
1506  jjmatchedPos = 4;
1507  }
1508  else if ((active1 & 0x4000000000000ULL) != 0L)
1509  {
1510  jjmatchedKind = 114;
1511  jjmatchedPos = 4;
1512  }
1513  break;
1514  case 77:
1515  return jjMoveStringLiteralDfa5_0(active0, 0x300000ULL, active1, 0x2000ULL);
1516  case 78:
1517  if ((active0 & 0x800000ULL) != 0L)
1518  {
1519  jjmatchedKind = 23;
1520  jjmatchedPos = 4;
1521  }
1522  return jjMoveStringLiteralDfa5_0(active0, 0x40000000000ULL, active1, 0x40000000000ULL);
1523  case 79:
1524  return jjMoveStringLiteralDfa5_0(active0, 0x810000000ULL, active1, 0L);
1525  case 80:
1526  if ((active0 & 0x2000000000000ULL) != 0L)
1527  {
1528  jjmatchedKind = 49;
1529  jjmatchedPos = 4;
1530  }
1531  else if ((active1 & 0x40000000000000ULL) != 0L)
1532  {
1533  jjmatchedKind = 118;
1534  jjmatchedPos = 4;
1535  }
1536  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x8000ULL);
1537  case 82:
1538  if ((active0 & 0x2000ULL) != 0L)
1539  {
1540  jjmatchedKind = 13;
1541  jjmatchedPos = 4;
1542  }
1543  else if ((active0 & 0x200000000ULL) != 0L)
1544  {
1545  jjmatchedKind = 33;
1546  jjmatchedPos = 4;
1547  }
1548  return jjMoveStringLiteralDfa5_0(active0, 0x1011800000080000ULL, active1, 0x92c400400ULL);
1549  case 83:
1550  if ((active0 & 0x4000ULL) != 0L)
1551  {
1552  jjmatchedKind = 14;
1553  jjmatchedPos = 4;
1554  }
1555  else if ((active1 & 0x2000000000000ULL) != 0L)
1556  {
1557  jjmatchedKind = 113;
1558  jjmatchedPos = 4;
1559  }
1560  return jjMoveStringLiteralDfa5_0(active0, 0x1000ULL, active1, 0x400000800000ULL);
1561  case 84:
1562  if ((active0 & 0x80000000000000ULL) != 0L)
1563  {
1564  jjmatchedKind = 55;
1565  jjmatchedPos = 4;
1566  }
1567  else if ((active1 & 0x80000000000000ULL) != 0L)
1568  {
1569  jjmatchedKind = 119;
1570  jjmatchedPos = 4;
1571  }
1572  return jjMoveStringLiteralDfa5_0(active0, 0x40411080000000ULL, active1, 0L);
1573  case 85:
1574  return jjMoveStringLiteralDfa5_0(active0, 0x400000000ULL, active1, 0L);
1575  case 89:
1576  if ((active0 & 0x40000ULL) != 0L)
1577  {
1578  jjmatchedKind = 18;
1579  jjmatchedPos = 4;
1580  }
1581  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x80000000000ULL);
1582  case 97:
1583  return jjMoveStringLiteralDfa5_0(active0, 0xc00000000000000ULL, active1, 0x10001002001000ULL);
1584  case 99:
1585  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x201000000ULL);
1586  case 100:
1587  return jjMoveStringLiteralDfa5_0(active0, 0x4000000000000ULL, active1, 0L);
1588  case 101:
1589  if ((active0 & 0x200000000000ULL) != 0L)
1590  {
1591  jjmatchedKind = 45;
1592  jjmatchedPos = 4;
1593  }
1594  else if ((active1 & 0x200000ULL) != 0L)
1595  {
1596  jjmatchedKind = 85;
1597  jjmatchedPos = 4;
1598  }
1599  else if ((active1 & 0x20000000000000ULL) != 0L)
1600  {
1601  jjmatchedKind = 117;
1602  jjmatchedPos = 4;
1603  }
1604  else if ((active1 & 0x400000000000000ULL) != 0L)
1605  {
1606  jjmatchedKind = 122;
1607  jjmatchedPos = 4;
1608  }
1609  return jjMoveStringLiteralDfa5_0(active0, 0x104000000ULL, active1, 0x24000f0000ULL);
1610  case 102:
1611  if ((active0 & 0x4000000000ULL) != 0L)
1612  {
1613  jjmatchedKind = 38;
1614  jjmatchedPos = 4;
1615  }
1616  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1000000000000ULL);
1617  case 105:
1618  return jjMoveStringLiteralDfa5_0(active0, 0x40420000ULL, active1, 0L);
1619  case 107:
1620  if ((active0 & 0x1000000ULL) != 0L)
1621  {
1622  jjmatchedKind = 24;
1623  jjmatchedPos = 4;
1624  }
1625  break;
1626  case 108:
1627  if ((active0 & 0x200000000000000ULL) != 0L)
1628  {
1629  jjmatchedKind = 57;
1630  jjmatchedPos = 4;
1631  }
1632  else if ((active1 & 0x4000000000000ULL) != 0L)
1633  {
1634  jjmatchedKind = 114;
1635  jjmatchedPos = 4;
1636  }
1637  break;
1638  case 109:
1639  return jjMoveStringLiteralDfa5_0(active0, 0x300000ULL, active1, 0x2000ULL);
1640  case 110:
1641  if ((active0 & 0x800000ULL) != 0L)
1642  {
1643  jjmatchedKind = 23;
1644  jjmatchedPos = 4;
1645  }
1646  return jjMoveStringLiteralDfa5_0(active0, 0x40000000000ULL, active1, 0x40000000000ULL);
1647  case 111:
1648  return jjMoveStringLiteralDfa5_0(active0, 0x810000000ULL, active1, 0L);
1649  case 112:
1650  if ((active0 & 0x2000000000000ULL) != 0L)
1651  {
1652  jjmatchedKind = 49;
1653  jjmatchedPos = 4;
1654  }
1655  else if ((active1 & 0x40000000000000ULL) != 0L)
1656  {
1657  jjmatchedKind = 118;
1658  jjmatchedPos = 4;
1659  }
1660  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x8000ULL);
1661  case 114:
1662  if ((active0 & 0x2000ULL) != 0L)
1663  {
1664  jjmatchedKind = 13;
1665  jjmatchedPos = 4;
1666  }
1667  else if ((active0 & 0x200000000ULL) != 0L)
1668  {
1669  jjmatchedKind = 33;
1670  jjmatchedPos = 4;
1671  }
1672  return jjMoveStringLiteralDfa5_0(active0, 0x1011800000080000ULL, active1, 0x92c400400ULL);
1673  case 115:
1674  if ((active0 & 0x4000ULL) != 0L)
1675  {
1676  jjmatchedKind = 14;
1677  jjmatchedPos = 4;
1678  }
1679  else if ((active1 & 0x2000000000000ULL) != 0L)
1680  {
1681  jjmatchedKind = 113;
1682  jjmatchedPos = 4;
1683  }
1684  return jjMoveStringLiteralDfa5_0(active0, 0x1000ULL, active1, 0x400000800000ULL);
1685  case 116:
1686  if ((active0 & 0x80000000000000ULL) != 0L)
1687  {
1688  jjmatchedKind = 55;
1689  jjmatchedPos = 4;
1690  }
1691  else if ((active1 & 0x80000000000000ULL) != 0L)
1692  {
1693  jjmatchedKind = 119;
1694  jjmatchedPos = 4;
1695  }
1696  return jjMoveStringLiteralDfa5_0(active0, 0x40411080000000ULL, active1, 0L);
1697  case 117:
1698  return jjMoveStringLiteralDfa5_0(active0, 0x400000000ULL, active1, 0L);
1699  case 121:
1700  if ((active0 & 0x40000ULL) != 0L)
1701  {
1702  jjmatchedKind = 18;
1703  jjmatchedPos = 4;
1704  }
1705  return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x80000000000ULL);
1706  default :
1707  break;
1708  }
1709  return jjMoveNfa_0(11, 4);
1710 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa5_0
int jjMoveStringLiteralDfa5_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:1712
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa5_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 1712 of file VhdlParserTokenManager.cc.

1712  {
1713  if (((active0 &= old0) | (active1 &= old1)) == 0L)
1714  return jjMoveNfa_0(11, 4);
1715  if (input_stream->endOfInput()) {
1716  return jjMoveNfa_0(11, 4);
1717  }
1718  curChar = input_stream->readChar();
1719  switch(curChar)
1720  {
1721  case 65:
1722  return jjMoveStringLiteralDfa6_0(active0, 0x1000800080000000ULL, active1, 0L);
1723  case 66:
1724  return jjMoveStringLiteralDfa6_0(active0, 0x400000ULL, active1, 0x10000000000000ULL);
1725  case 67:
1726  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x80000ULL);
1727  case 68:
1728  if ((active1 & 0x400000ULL) != 0L)
1729  {
1730  jjmatchedKind = 86;
1731  jjmatchedPos = 5;
1732  }
1733  else if ((active1 & 0x2000000000ULL) != 0L)
1734  {
1735  jjmatchedKind = 101;
1736  jjmatchedPos = 5;
1737  }
1738  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x10000ULL);
1739  case 69:
1740  if ((active0 & 0x100000ULL) != 0L)
1741  {
1742  jjmatchedKind = 20;
1743  jjmatchedPos = 5;
1744  }
1745  else if ((active0 & 0x10000000000000ULL) != 0L)
1746  {
1747  jjmatchedKind = 52;
1748  jjmatchedPos = 5;
1749  }
1750  return jjMoveStringLiteralDfa6_0(active0, 0x4040000200000ULL, active1, 0x1000000002000ULL);
1751  case 71:
1752  if ((active1 & 0x40000000000ULL) != 0L)
1753  {
1754  jjmatchedKind = 106;
1755  jjmatchedPos = 5;
1756  }
1757  return jjMoveStringLiteralDfa6_0(active0, 0x800000040000000ULL, active1, 0x1000ULL);
1758  case 73:
1759  return jjMoveStringLiteralDfa6_0(active0, 0x41400000000000ULL, active1, 0x80c000000ULL);
1760  case 76:
1761  if ((active1 & 0x1000000000ULL) != 0L)
1762  {
1763  jjmatchedKind = 100;
1764  jjmatchedPos = 5;
1765  }
1766  return jjMoveStringLiteralDfa6_0(active0, 0x400000000ULL, active1, 0L);
1767  case 78:
1768  if ((active1 & 0x100000000ULL) != 0L)
1769  {
1770  jjmatchedKind = 96;
1771  jjmatchedPos = 5;
1772  }
1773  return jjMoveStringLiteralDfa6_0(active0, 0x810000000ULL, active1, 0x400000000ULL);
1774  case 79:
1775  if ((active0 & 0x1000000000ULL) != 0L)
1776  {
1777  jjmatchedKind = 36;
1778  jjmatchedPos = 5;
1779  }
1780  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8000ULL);
1781  case 80:
1782  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x480000000000ULL);
1783  case 82:
1784  if ((active0 & 0x4000000ULL) != 0L)
1785  {
1786  jjmatchedKind = 26;
1787  jjmatchedPos = 5;
1788  }
1789  return jjMoveStringLiteralDfa6_0(active0, 0x400000000000000ULL, active1, 0x40000ULL);
1790  case 83:
1791  if ((active0 & 0x1000ULL) != 0L)
1792  {
1793  jjmatchedKind = 12;
1794  jjmatchedPos = 5;
1795  }
1796  else if ((active1 & 0x400ULL) != 0L)
1797  {
1798  jjmatchedKind = 74;
1799  jjmatchedPos = 5;
1800  }
1801  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2020000ULL);
1802  case 84:
1803  if ((active0 & 0x80000ULL) != 0L)
1804  {
1805  jjmatchedKind = 19;
1806  jjmatchedPos = 5;
1807  }
1808  else if ((active1 & 0x1000000ULL) != 0L)
1809  {
1810  jjmatchedKind = 88;
1811  jjmatchedPos = 5;
1812  }
1813  else if ((active1 & 0x20000000ULL) != 0L)
1814  {
1815  jjmatchedKind = 93;
1816  jjmatchedPos = 5;
1817  }
1818  else if ((active1 & 0x200000000ULL) != 0L)
1819  {
1820  jjmatchedKind = 97;
1821  jjmatchedPos = 5;
1822  }
1823  return jjMoveStringLiteralDfa6_0(active0, 0x20000ULL, active1, 0x800000ULL);
1824  case 88:
1825  return jjMoveStringLiteralDfa6_0(active0, 0x100000000ULL, active1, 0L);
1826  case 89:
1827  if ((active0 & 0x10000000000ULL) != 0L)
1828  {
1829  jjmatchedKind = 40;
1830  jjmatchedPos = 5;
1831  }
1832  break;
1833  case 97:
1834  return jjMoveStringLiteralDfa6_0(active0, 0x1000800080000000ULL, active1, 0L);
1835  case 98:
1836  return jjMoveStringLiteralDfa6_0(active0, 0x400000ULL, active1, 0x10000000000000ULL);
1837  case 99:
1838  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x80000ULL);
1839  case 100:
1840  if ((active1 & 0x400000ULL) != 0L)
1841  {
1842  jjmatchedKind = 86;
1843  jjmatchedPos = 5;
1844  }
1845  else if ((active1 & 0x2000000000ULL) != 0L)
1846  {
1847  jjmatchedKind = 101;
1848  jjmatchedPos = 5;
1849  }
1850  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x10000ULL);
1851  case 101:
1852  if ((active0 & 0x100000ULL) != 0L)
1853  {
1854  jjmatchedKind = 20;
1855  jjmatchedPos = 5;
1856  }
1857  else if ((active0 & 0x10000000000000ULL) != 0L)
1858  {
1859  jjmatchedKind = 52;
1860  jjmatchedPos = 5;
1861  }
1862  return jjMoveStringLiteralDfa6_0(active0, 0x4040000200000ULL, active1, 0x1000000002000ULL);
1863  case 103:
1864  if ((active1 & 0x40000000000ULL) != 0L)
1865  {
1866  jjmatchedKind = 106;
1867  jjmatchedPos = 5;
1868  }
1869  return jjMoveStringLiteralDfa6_0(active0, 0x800000040000000ULL, active1, 0x1000ULL);
1870  case 105:
1871  return jjMoveStringLiteralDfa6_0(active0, 0x41400000000000ULL, active1, 0x80c000000ULL);
1872  case 108:
1873  if ((active1 & 0x1000000000ULL) != 0L)
1874  {
1875  jjmatchedKind = 100;
1876  jjmatchedPos = 5;
1877  }
1878  return jjMoveStringLiteralDfa6_0(active0, 0x400000000ULL, active1, 0L);
1879  case 110:
1880  if ((active1 & 0x100000000ULL) != 0L)
1881  {
1882  jjmatchedKind = 96;
1883  jjmatchedPos = 5;
1884  }
1885  return jjMoveStringLiteralDfa6_0(active0, 0x810000000ULL, active1, 0x400000000ULL);
1886  case 111:
1887  if ((active0 & 0x1000000000ULL) != 0L)
1888  {
1889  jjmatchedKind = 36;
1890  jjmatchedPos = 5;
1891  }
1892  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x8000ULL);
1893  case 112:
1894  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x480000000000ULL);
1895  case 114:
1896  if ((active0 & 0x4000000ULL) != 0L)
1897  {
1898  jjmatchedKind = 26;
1899  jjmatchedPos = 5;
1900  }
1901  return jjMoveStringLiteralDfa6_0(active0, 0x400000000000000ULL, active1, 0x40000ULL);
1902  case 115:
1903  if ((active0 & 0x1000ULL) != 0L)
1904  {
1905  jjmatchedKind = 12;
1906  jjmatchedPos = 5;
1907  }
1908  else if ((active1 & 0x400ULL) != 0L)
1909  {
1910  jjmatchedKind = 74;
1911  jjmatchedPos = 5;
1912  }
1913  return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x2020000ULL);
1914  case 116:
1915  if ((active0 & 0x80000ULL) != 0L)
1916  {
1917  jjmatchedKind = 19;
1918  jjmatchedPos = 5;
1919  }
1920  else if ((active1 & 0x1000000ULL) != 0L)
1921  {
1922  jjmatchedKind = 88;
1923  jjmatchedPos = 5;
1924  }
1925  else if ((active1 & 0x20000000ULL) != 0L)
1926  {
1927  jjmatchedKind = 93;
1928  jjmatchedPos = 5;
1929  }
1930  else if ((active1 & 0x200000000ULL) != 0L)
1931  {
1932  jjmatchedKind = 97;
1933  jjmatchedPos = 5;
1934  }
1935  return jjMoveStringLiteralDfa6_0(active0, 0x20000ULL, active1, 0x800000ULL);
1936  case 120:
1937  return jjMoveStringLiteralDfa6_0(active0, 0x100000000ULL, active1, 0L);
1938  case 121:
1939  if ((active0 & 0x10000000000ULL) != 0L)
1940  {
1941  jjmatchedKind = 40;
1942  jjmatchedPos = 5;
1943  }
1944  break;
1945  default :
1946  break;
1947  }
1948  return jjMoveNfa_0(11, 5);
1949 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa6_0
int jjMoveStringLiteralDfa6_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:1951
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa6_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 1951 of file VhdlParserTokenManager.cc.

1951  {
1952  if (((active0 &= old0) | (active1 &= old1)) == 0L)
1953  return jjMoveNfa_0(11, 5);
1954  if (input_stream->endOfInput()) {
1955  return jjMoveNfa_0(11, 5);
1956  }
1957  curChar = input_stream->readChar();
1958  switch(curChar)
1959  {
1960  case 65:
1961  return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000ULL, active1, 0L);
1962  case 67:
1963  if ((active0 & 0x1000000000000ULL) != 0L)
1964  {
1965  jjmatchedKind = 48;
1966  jjmatchedPos = 6;
1967  }
1968  return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x100040c000000ULL);
1969  case 68:
1970  if ((active0 & 0x4000000000000ULL) != 0L)
1971  {
1972  jjmatchedKind = 50;
1973  jjmatchedPos = 6;
1974  }
1975  break;
1976  case 69:
1977  if ((active0 & 0x800000000000000ULL) != 0L)
1978  {
1979  jjmatchedKind = 59;
1980  jjmatchedPos = 6;
1981  }
1982  else if ((active1 & 0x1000ULL) != 0L)
1983  {
1984  jjmatchedKind = 76;
1985  jjmatchedPos = 6;
1986  }
1987  else if ((active1 & 0x2000000ULL) != 0L)
1988  {
1989  jjmatchedKind = 89;
1990  jjmatchedPos = 6;
1991  }
1992  else if ((active1 & 0x80000000000ULL) != 0L)
1993  {
1994  jjmatchedKind = 107;
1995  jjmatchedPos = 6;
1996  }
1997  return jjMoveStringLiteralDfa7_0(active0, 0x10020000ULL, active1, 0x800000ULL);
1998  case 76:
1999  if ((active0 & 0x1000000000000000ULL) != 0L)
2000  {
2001  jjmatchedKind = 60;
2002  jjmatchedPos = 6;
2003  }
2004  return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x10000000000000ULL);
2005  case 78:
2006  return jjMoveStringLiteralDfa7_0(active0, 0x880000000ULL, active1, 0x8000ULL);
2007  case 79:
2008  return jjMoveStringLiteralDfa7_0(active0, 0x400000000000ULL, active1, 0x400000000000ULL);
2009  case 83:
2010  if ((active1 & 0x20000ULL) != 0L)
2011  {
2012  jjmatchedKind = 81;
2013  jjmatchedPos = 6;
2014  }
2015  return jjMoveStringLiteralDfa7_0(active0, 0x40000000000ULL, active1, 0L);
2016  case 84:
2017  if ((active0 & 0x100000000ULL) != 0L)
2018  {
2019  jjmatchedKind = 32;
2020  jjmatchedPos = 6;
2021  }
2022  else if ((active0 & 0x400000000ULL) != 0L)
2023  {
2024  jjmatchedKind = 34;
2025  jjmatchedPos = 6;
2026  }
2027  return jjMoveStringLiteralDfa7_0(active0, 0x800000000000ULL, active1, 0x8000c2000ULL);
2028  case 85:
2029  return jjMoveStringLiteralDfa7_0(active0, 0x40400000ULL, active1, 0x10000ULL);
2030  case 89:
2031  if ((active0 & 0x400000000000000ULL) != 0L)
2032  {
2033  jjmatchedKind = 58;
2034  jjmatchedPos = 6;
2035  }
2036  break;
2037  case 95:
2038  return jjMoveStringLiteralDfa7_0(active0, 0x200000ULL, active1, 0L);
2039  case 97:
2040  return jjMoveStringLiteralDfa7_0(active0, 0x40000000000000ULL, active1, 0L);
2041  case 99:
2042  if ((active0 & 0x1000000000000ULL) != 0L)
2043  {
2044  jjmatchedKind = 48;
2045  jjmatchedPos = 6;
2046  }
2047  return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x100040c000000ULL);
2048  case 100:
2049  if ((active0 & 0x4000000000000ULL) != 0L)
2050  {
2051  jjmatchedKind = 50;
2052  jjmatchedPos = 6;
2053  }
2054  break;
2055  case 101:
2056  if ((active0 & 0x800000000000000ULL) != 0L)
2057  {
2058  jjmatchedKind = 59;
2059  jjmatchedPos = 6;
2060  }
2061  else if ((active1 & 0x1000ULL) != 0L)
2062  {
2063  jjmatchedKind = 76;
2064  jjmatchedPos = 6;
2065  }
2066  else if ((active1 & 0x2000000ULL) != 0L)
2067  {
2068  jjmatchedKind = 89;
2069  jjmatchedPos = 6;
2070  }
2071  else if ((active1 & 0x80000000000ULL) != 0L)
2072  {
2073  jjmatchedKind = 107;
2074  jjmatchedPos = 6;
2075  }
2076  return jjMoveStringLiteralDfa7_0(active0, 0x10020000ULL, active1, 0x800000ULL);
2077  case 108:
2078  if ((active0 & 0x1000000000000000ULL) != 0L)
2079  {
2080  jjmatchedKind = 60;
2081  jjmatchedPos = 6;
2082  }
2083  return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x10000000000000ULL);
2084  case 110:
2085  return jjMoveStringLiteralDfa7_0(active0, 0x880000000ULL, active1, 0x8000ULL);
2086  case 111:
2087  return jjMoveStringLiteralDfa7_0(active0, 0x400000000000ULL, active1, 0x400000000000ULL);
2088  case 115:
2089  if ((active1 & 0x20000ULL) != 0L)
2090  {
2091  jjmatchedKind = 81;
2092  jjmatchedPos = 6;
2093  }
2094  return jjMoveStringLiteralDfa7_0(active0, 0x40000000000ULL, active1, 0L);
2095  case 116:
2096  if ((active0 & 0x100000000ULL) != 0L)
2097  {
2098  jjmatchedKind = 32;
2099  jjmatchedPos = 6;
2100  }
2101  else if ((active0 & 0x400000000ULL) != 0L)
2102  {
2103  jjmatchedKind = 34;
2104  jjmatchedPos = 6;
2105  }
2106  return jjMoveStringLiteralDfa7_0(active0, 0x800000000000ULL, active1, 0x8000c2000ULL);
2107  case 117:
2108  return jjMoveStringLiteralDfa7_0(active0, 0x40400000ULL, active1, 0x10000ULL);
2109  case 121:
2110  if ((active0 & 0x400000000000000ULL) != 0L)
2111  {
2112  jjmatchedKind = 58;
2113  jjmatchedPos = 6;
2114  }
2115  break;
2116  default :
2117  break;
2118  }
2119  return jjMoveNfa_0(11, 6);
2120 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa7_0
int jjMoveStringLiteralDfa7_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2122
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa7_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2122 of file VhdlParserTokenManager.cc.

2122  {
2123  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2124  return jjMoveNfa_0(11, 6);
2125  if (input_stream->endOfInput()) {
2126  return jjMoveNfa_0(11, 6);
2127  }
2128  curChar = input_stream->readChar();
2129  switch(curChar)
2130  {
2131  case 67:
2132  return jjMoveStringLiteralDfa8_0(active0, 0x20000ULL, active1, 0L);
2133  case 69:
2134  if ((active0 & 0x800000000000ULL) != 0L)
2135  {
2136  jjmatchedKind = 47;
2137  jjmatchedPos = 7;
2138  }
2139  else if ((active1 & 0x400000000ULL) != 0L)
2140  {
2141  jjmatchedKind = 98;
2142  jjmatchedPos = 7;
2143  }
2144  else if ((active1 & 0x10000000000000ULL) != 0L)
2145  {
2146  jjmatchedKind = 116;
2147  jjmatchedPos = 7;
2148  }
2149  return jjMoveStringLiteralDfa8_0(active0, 0x800000000ULL, active1, 0x8a000ULL);
2150  case 71:
2151  return jjMoveStringLiteralDfa8_0(active0, 0x200000ULL, active1, 0L);
2152  case 76:
2153  if ((active0 & 0x40000000000000ULL) != 0L)
2154  {
2155  jjmatchedKind = 54;
2156  jjmatchedPos = 7;
2157  }
2158  break;
2159  case 78:
2160  if ((active0 & 0x400000000000ULL) != 0L)
2161  {
2162  jjmatchedKind = 46;
2163  jjmatchedPos = 7;
2164  }
2165  return jjMoveStringLiteralDfa8_0(active0, 0x10000000ULL, active1, 0L);
2166  case 82:
2167  if ((active1 & 0x800000ULL) != 0L)
2168  {
2169  jjmatchedKind = 87;
2170  jjmatchedPos = 7;
2171  }
2172  return jjMoveStringLiteralDfa8_0(active0, 0x40000000ULL, active1, 0x400000010000ULL);
2173  case 83:
2174  if ((active0 & 0x40000000000ULL) != 0L)
2175  {
2176  jjmatchedKind = 42;
2177  jjmatchedPos = 7;
2178  }
2179  break;
2180  case 84:
2181  if ((active0 & 0x80000000ULL) != 0L)
2182  {
2183  jjmatchedKind = 31;
2184  jjmatchedPos = 7;
2185  }
2186  else if ((active1 & 0x4000000ULL) != 0L)
2187  {
2188  jjmatchedKind = 90;
2189  jjmatchedPos = 7;
2190  }
2191  return jjMoveStringLiteralDfa8_0(active0, 0x400000ULL, active1, 0x1000008000000ULL);
2192  case 89:
2193  if ((active1 & 0x40000ULL) != 0L)
2194  {
2195  jjmatchedKind = 82;
2196  jjmatchedPos = 7;
2197  }
2198  else if ((active1 & 0x800000000ULL) != 0L)
2199  {
2200  jjmatchedKind = 99;
2201  jjmatchedPos = 7;
2202  }
2203  break;
2204  case 99:
2205  return jjMoveStringLiteralDfa8_0(active0, 0x20000ULL, active1, 0L);
2206  case 101:
2207  if ((active0 & 0x800000000000ULL) != 0L)
2208  {
2209  jjmatchedKind = 47;
2210  jjmatchedPos = 7;
2211  }
2212  else if ((active1 & 0x400000000ULL) != 0L)
2213  {
2214  jjmatchedKind = 98;
2215  jjmatchedPos = 7;
2216  }
2217  else if ((active1 & 0x10000000000000ULL) != 0L)
2218  {
2219  jjmatchedKind = 116;
2220  jjmatchedPos = 7;
2221  }
2222  return jjMoveStringLiteralDfa8_0(active0, 0x800000000ULL, active1, 0x8a000ULL);
2223  case 103:
2224  return jjMoveStringLiteralDfa8_0(active0, 0x200000ULL, active1, 0L);
2225  case 108:
2226  if ((active0 & 0x40000000000000ULL) != 0L)
2227  {
2228  jjmatchedKind = 54;
2229  jjmatchedPos = 7;
2230  }
2231  break;
2232  case 110:
2233  if ((active0 & 0x400000000000ULL) != 0L)
2234  {
2235  jjmatchedKind = 46;
2236  jjmatchedPos = 7;
2237  }
2238  return jjMoveStringLiteralDfa8_0(active0, 0x10000000ULL, active1, 0L);
2239  case 114:
2240  if ((active1 & 0x800000ULL) != 0L)
2241  {
2242  jjmatchedKind = 87;
2243  jjmatchedPos = 7;
2244  }
2245  return jjMoveStringLiteralDfa8_0(active0, 0x40000000ULL, active1, 0x400000010000ULL);
2246  case 115:
2247  if ((active0 & 0x40000000000ULL) != 0L)
2248  {
2249  jjmatchedKind = 42;
2250  jjmatchedPos = 7;
2251  }
2252  break;
2253  case 116:
2254  if ((active0 & 0x80000000ULL) != 0L)
2255  {
2256  jjmatchedKind = 31;
2257  jjmatchedPos = 7;
2258  }
2259  else if ((active1 & 0x4000000ULL) != 0L)
2260  {
2261  jjmatchedKind = 90;
2262  jjmatchedPos = 7;
2263  }
2264  return jjMoveStringLiteralDfa8_0(active0, 0x400000ULL, active1, 0x1000008000000ULL);
2265  case 121:
2266  if ((active1 & 0x40000ULL) != 0L)
2267  {
2268  jjmatchedKind = 82;
2269  jjmatchedPos = 7;
2270  }
2271  else if ((active1 & 0x800000000ULL) != 0L)
2272  {
2273  jjmatchedKind = 99;
2274  jjmatchedPos = 7;
2275  }
2276  break;
2277  default :
2278  break;
2279  }
2280  return jjMoveNfa_0(11, 7);
2281 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa8_0
int jjMoveStringLiteralDfa8_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2283
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa8_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2283 of file VhdlParserTokenManager.cc.

2283  {
2284  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2285  return jjMoveNfa_0(11, 7);
2286  if (input_stream->endOfInput()) {
2287  return jjMoveNfa_0(11, 7);
2288  }
2289  curChar = input_stream->readChar();
2290  switch(curChar)
2291  {
2292  case 65:
2293  return jjMoveStringLiteralDfa9_0(active0, 0x40000000ULL, active1, 0L);
2294  case 67:
2295  return jjMoveStringLiteralDfa9_0(active0, 0x800000000ULL, active1, 0L);
2296  case 68:
2297  if ((active1 & 0x8000ULL) != 0L)
2298  {
2299  jjmatchedKind = 79;
2300  jjmatchedPos = 8;
2301  }
2302  else if ((active1 & 0x80000ULL) != 0L)
2303  {
2304  jjmatchedKind = 83;
2305  jjmatchedPos = 8;
2306  }
2307  break;
2308  case 69:
2309  if ((active0 & 0x400000ULL) != 0L)
2310  {
2311  jjmatchedKind = 22;
2312  jjmatchedPos = 8;
2313  }
2314  else if ((active1 & 0x10000ULL) != 0L)
2315  {
2316  jjmatchedKind = 80;
2317  jjmatchedPos = 8;
2318  }
2319  return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000ULL);
2320  case 82:
2321  if ((active1 & 0x2000ULL) != 0L)
2322  {
2323  jjmatchedKind = 77;
2324  jjmatchedPos = 8;
2325  }
2326  break;
2327  case 84:
2328  if ((active0 & 0x10000000ULL) != 0L)
2329  {
2330  jjmatchedKind = 28;
2331  jjmatchedPos = 8;
2332  }
2333  else if ((active1 & 0x400000000000ULL) != 0L)
2334  {
2335  jjmatchedKind = 110;
2336  jjmatchedPos = 8;
2337  }
2338  return jjMoveStringLiteralDfa9_0(active0, 0x20000ULL, active1, 0L);
2339  case 85:
2340  return jjMoveStringLiteralDfa9_0(active0, 0x200000ULL, active1, 0L);
2341  case 95:
2342  return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x8000000ULL);
2343  case 97:
2344  return jjMoveStringLiteralDfa9_0(active0, 0x40000000ULL, active1, 0L);
2345  case 99:
2346  return jjMoveStringLiteralDfa9_0(active0, 0x800000000ULL, active1, 0L);
2347  case 100:
2348  if ((active1 & 0x8000ULL) != 0L)
2349  {
2350  jjmatchedKind = 79;
2351  jjmatchedPos = 8;
2352  }
2353  else if ((active1 & 0x80000ULL) != 0L)
2354  {
2355  jjmatchedKind = 83;
2356  jjmatchedPos = 8;
2357  }
2358  break;
2359  case 101:
2360  if ((active0 & 0x400000ULL) != 0L)
2361  {
2362  jjmatchedKind = 22;
2363  jjmatchedPos = 8;
2364  }
2365  else if ((active1 & 0x10000ULL) != 0L)
2366  {
2367  jjmatchedKind = 80;
2368  jjmatchedPos = 8;
2369  }
2370  return jjMoveStringLiteralDfa9_0(active0, 0L, active1, 0x1000000000000ULL);
2371  case 114:
2372  if ((active1 & 0x2000ULL) != 0L)
2373  {
2374  jjmatchedKind = 77;
2375  jjmatchedPos = 8;
2376  }
2377  break;
2378  case 116:
2379  if ((active0 & 0x10000000ULL) != 0L)
2380  {
2381  jjmatchedKind = 28;
2382  jjmatchedPos = 8;
2383  }
2384  else if ((active1 & 0x400000000000ULL) != 0L)
2385  {
2386  jjmatchedKind = 110;
2387  jjmatchedPos = 8;
2388  }
2389  return jjMoveStringLiteralDfa9_0(active0, 0x20000ULL, active1, 0L);
2390  case 117:
2391  return jjMoveStringLiteralDfa9_0(active0, 0x200000ULL, active1, 0L);
2392  default :
2393  break;
2394  }
2395  return jjMoveNfa_0(11, 8);
2396 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa9_0
int jjMoveStringLiteralDfa9_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2398
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa9_0 ( unsigned long long  old0,
unsigned long long  active0,
unsigned long long  old1,
unsigned long long  active1 
)

Definition at line 2398 of file VhdlParserTokenManager.cc.

2398  {
2399  if (((active0 &= old0) | (active1 &= old1)) == 0L)
2400  return jjMoveNfa_0(11, 8);
2401  if (input_stream->endOfInput()) {
2402  return jjMoveNfa_0(11, 8);
2403  }
2404  curChar = input_stream->readChar();
2405  switch(curChar)
2406  {
2407  case 65:
2408  return jjMoveStringLiteralDfa10_0(active0, 0x200000ULL, active1, 0L);
2409  case 68:
2410  if ((active1 & 0x1000000000000ULL) != 0L)
2411  {
2412  jjmatchedKind = 112;
2413  jjmatchedPos = 9;
2414  }
2415  break;
2416  case 71:
2417  return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000ULL);
2418  case 84:
2419  if ((active0 & 0x800000000ULL) != 0L)
2420  {
2421  jjmatchedKind = 35;
2422  jjmatchedPos = 9;
2423  }
2424  return jjMoveStringLiteralDfa10_0(active0, 0x40000000ULL, active1, 0L);
2425  case 85:
2426  return jjMoveStringLiteralDfa10_0(active0, 0x20000ULL, active1, 0L);
2427  case 97:
2428  return jjMoveStringLiteralDfa10_0(active0, 0x200000ULL, active1, 0L);
2429  case 100:
2430  if ((active1 & 0x1000000000000ULL) != 0L)
2431  {
2432  jjmatchedKind = 112;
2433  jjmatchedPos = 9;
2434  }
2435  break;
2436  case 103:
2437  return jjMoveStringLiteralDfa10_0(active0, 0L, active1, 0x8000000ULL);
2438  case 116:
2439  if ((active0 & 0x800000000ULL) != 0L)
2440  {
2441  jjmatchedKind = 35;
2442  jjmatchedPos = 9;
2443  }
2444  return jjMoveStringLiteralDfa10_0(active0, 0x40000000ULL, active1, 0L);
2445  case 117:
2446  return jjMoveStringLiteralDfa10_0(active0, 0x20000ULL, active1, 0L);
2447  default :
2448  break;
2449  }
2450  return jjMoveNfa_0(11, 9);
2451 }
vhdl::parser::VhdlParserTokenManager::jjMoveStringLiteralDfa10_0
int jjMoveStringLiteralDfa10_0(unsigned long long old0, unsigned long long active0, unsigned long long old1, unsigned long long active1)
Definition: VhdlParserTokenManager.cc:2453
vhdl::parser::VhdlParserTokenManager::jjMoveNfa_0
int jjMoveNfa_0(int startState, int curPos)
Definition: VhdlParserTokenManager.cc:2677
int vhdl::parser::VhdlParserTokenManager::jjStopAtPos ( int  pos,
int  kind 
)

Definition at line 445 of file VhdlParserTokenManager.cc.

445  {
446  jjmatchedKind = kind;
447  jjmatchedPos = pos;
448  return pos + 1;
449 }
void vhdl::parser::VhdlParserTokenManager::ReInit ( JAVACC_CHARSTREAM *  stream,
int  lexState = 0,
VhdlParser *  parserArg = NULL 
)

Reinitialise parser.

Definition at line 3588 of file VhdlParserTokenManager.cc.

3588  {
3589  clear();
3590  jjmatchedPos = jjnewStateCnt = 0;
3591  curLexState = lexState;
3592  input_stream = stream;
3593  ReInitRounds();
3594  debugStream = stdout; // init
3595  SwitchTo(lexState);
3596  parser = parserArg;
3597  errorHandler = new TokenManagerErrorHandler();
3598  errorHandlerCreated = true;
3599  }
generate_datataset.stdout
stdout
Definition: generate_datataset.py:30
generate_datataset.stream
stream
Definition: generate_datataset.py:30
void vhdl::parser::VhdlParserTokenManager::ReInitRounds ( )
private

Definition at line 3601 of file VhdlParserTokenManager.cc.

3601  {
3602  int i;
3603  jjround = 0x80000001;
3604  for (i = 76; i-- > 0;)
3605  jjrounds[i] = 0x80000000;
3606  }
void vhdl::parser::VhdlParserTokenManager::setDebugStream ( FILE *  ds)

Set debug output.

Definition at line 443 of file VhdlParserTokenManager.cc.

443 { debugStream = ds; }
void vhdl::parser::VhdlParserTokenManager::setErrorHandler ( TokenManagerErrorHandler *  eh)
inline

Definition at line 135 of file VhdlParserTokenManager.h.

135  {
136  if (errorHandlerCreated && errorHandler != NULL) delete errorHandler;
137  errorHandler = eh;
138  errorHandlerCreated = false;
139  }
void vhdl::parser::VhdlParserTokenManager::SkipLexicalActions ( Token *  matchedToken)

Definition at line 3407 of file VhdlParserTokenManager.cc.

3407  {
3408  switch(jjmatchedKind)
3409  {
3410  case 3 : {
3411  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3412  ::vhdl::parser::VhdlParser::lineCount();
3413  break;
3414  }
3415  case 6 : {
3416  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3417  {
3418  QCString doc(image.data());
3419  int count=doc.contains("--!");
3420  ::vhdl::parser::VhdlParser::setMultCommentLine();
3421  ::vhdl::parser::VhdlParser::lineCount(image.data());
3422  if (count == 1)
3423  ::vhdl::parser::VhdlParser::oneLineComment(doc);
3424  else
3425  ::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),FALSE); ;
3426  }
3427  break;
3428  }
3429  case 7 : {
3430  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3431  ::vhdl::parser::VhdlParser::handleFlowComment(image.data());
3432  break;
3433  }
3434  case 8 : {
3435  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3436  ::vhdl::parser::VhdlParser::lineCount(image.data());
3437  break;
3438  }
3439  case 9 : {
3440  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3441  {
3442  QCString q(image.data());
3443  q.stripPrefix("/*!");
3444  q.resize(q.length()-2);
3445  ::vhdl::parser::VhdlParser::handleCommentBlock(q.data(),TRUE);image.clear();
3446  }
3447  break;
3448  }
3449  case 10 : {
3450  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3451  ::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();
3452  break;
3453  }
3454  default :
3455  break;
3456  }
3457 }
vhdl::parser::VhdlParser::oneLineComment
static void oneLineComment(QCString qcs)
Definition: vhdljjparser.cpp:791
QCString::contains
int contains(char c, bool cs=TRUE) const
Definition: qcstring.cpp:153
FALSE
const bool FALSE
Definition: qglobal.h:370
vhdl::parser::VhdlParser::handleFlowComment
static void handleFlowComment(const char *)
Definition: vhdljjparser.cpp:295
QCString::stripPrefix
bool stripPrefix(const char *prefix)
Definition: qcstring.cpp:201
handleCommentBlock
static void handleCommentBlock(const QCString &doc, bool brief)
Definition: fortranscanner.cpp:60503
doc
QCString doc
Definition: vhdljjparser.cpp:77
reco_momentum_tuples.count
int count
Definition: reco_momentum_tuples.py:202
vhdl::parser::VhdlParser::setMultCommentLine
static void setMultCommentLine()
Definition: vhdljjparser.cpp:786
vhdl::parser::VhdlParser::handleCommentBlock
static void handleCommentBlock(const char *doc, bool brief)
Definition: vhdljjparser.cpp:309
TRUE
const bool TRUE
Definition: qglobal.h:371
void vhdl::parser::VhdlParserTokenManager::SwitchTo ( int  lexState)

Switch to specified lex state.

Definition at line 3609 of file VhdlParserTokenManager.cc.

3609  {
3610  if (lexState >= 1 || lexState < 0) {
3611  JAVACC_STRING_TYPE message;
3612 #ifdef WIDE_CHAR
3613  message += L"Error: Ignoring invalid lexical state : ";
3614  message += lexState; message += L". State unchanged.";
3615 #else
3616  message += "Error: Ignoring invalid lexical state : ";
3617  message += lexState; message += ". State unchanged.";
3618 #endif
3619  throw new TokenMgrError(message, INVALID_LEXICAL_STATE);
3620  } else
3621  curLexState = lexState;
3622  }
JAVACC_STRING_TYPE
#define JAVACC_STRING_TYPE
Definition: JavaCC.h:16
python.root_metadata.message
message
Definition: root_metadata.py:29
void vhdl::parser::VhdlParserTokenManager::TokenLexicalActions ( Token *  matchedToken)

Definition at line 3459 of file VhdlParserTokenManager.cc.

3459  {
3460  switch(jjmatchedKind)
3461  {
3462  case 17 : {
3463  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3464  ::vhdl::parser::VhdlParser::setLineParsed(ARCHITECTURE_T);
3465  break;
3466  }
3467  case 18 : {
3468  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3469  VhdlParser::setLineParsed(ARRAY_T);
3470  break;
3471  }
3472  case 22 : {
3473  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3474  ::vhdl::parser::VhdlParser::setLineParsed(ATTRIBUTE_T);
3475  break;
3476  }
3477  case 25 : {
3478  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3479  ::vhdl::parser::VhdlParser::setLineParsed(BODY_T);
3480  break;
3481  }
3482  case 28 : {
3483  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3484  VhdlParser::setLineParsed(COMPONENT_T);
3485  break;
3486  }
3487  case 30 : {
3488  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3489  VhdlParser::setLineParsed(CONFIGURATION_T);
3490  break;
3491  }
3492  case 31 : {
3493  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3494  VhdlParser::setLineParsed(CONSTANT_T);
3495  break;
3496  }
3497  case 32 : {
3498  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3499  VhdlParser::setLineParsed(CONTEXT_T);
3500  break;
3501  }
3502  case 39 : {
3503  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3504  VhdlParser::setLineParsed(END_T);
3505  break;
3506  }
3507  case 40 : {
3508  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3509  VhdlParser::setLineParsed(ENTITY_T);
3510  break;
3511  }
3512  case 43 : {
3513  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3514  VhdlParser::setLineParsed(FILE_T);
3515  break;
3516  }
3517  case 46 : {
3518  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3519  VhdlParser::setLineParsed(FUNCTION_T);
3520  break;
3521  }
3522  case 49 : {
3523  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3524  VhdlParser::setLineParsed(GROUP_T);
3525  break;
3526  }
3527  case 58 : {
3528  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3529  VhdlParser::setLineParsed(LIBRARY_T);
3530  break;
3531  }
3532  case 76 : {
3533  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3534  ::vhdl::parser::VhdlParser::setLineParsed(PACKAGE_T);
3535  break;
3536  }
3537  case 78 : {
3538  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3539  ::vhdl::parser::VhdlParser::setLineParsed(PORT_T);
3540  break;
3541  }
3542  case 80 : {
3543  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3544  ::vhdl::parser::VhdlParser::setLineParsed(PROCEDURE_T);
3545  break;
3546  }
3547  case 81 : {
3548  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3549  ::vhdl::parser::VhdlParser::setLineParsed(PROCESS_T);
3550  break;
3551  }
3552  case 86 : {
3553  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3554  ::vhdl::parser::VhdlParser::setLineParsed(RECORD_T);
3555  break;
3556  }
3557  case 100 : {
3558  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3559  ::vhdl::parser::VhdlParser::setLineParsed(SIGNAL_T);
3560  break;
3561  }
3562  case 107 : {
3563  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3564  ::vhdl::parser::VhdlParser::setLineParsed(SUBTYPE_T);
3565  break;
3566  }
3567  case 111 : {
3568  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3569  ::vhdl::parser::VhdlParser::setLineParsed(TYPE_T);
3570  break;
3571  }
3572  case 113 : {
3573  image.append(input_stream->GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1)));
3574  ::vhdl::parser::VhdlParser::setLineParsed(UNITS_T);
3575  break;
3576  }
3577  case 137 : {
3578  image.append(jjstrLiteralImages[137]);
3579  lengthOfMatch = jjstrLiteralImages[137].length();
3580  ::vhdl::parser::VhdlParser::setLineParsed(SEMI_T);
3581  break;
3582  }
3583  default :
3584  break;
3585  }
3586 }
vhdl::parser::ATTRIBUTE_T
const int ATTRIBUTE_T
Definition: VhdlParserConstants.h:50
vhdl::parser::COMPONENT_T
const int COMPONENT_T
Definition: VhdlParserConstants.h:62
vhdl::parser::CONSTANT_T
const int CONSTANT_T
Definition: VhdlParserConstants.h:68
vhdl::parser::FUNCTION_T
const int FUNCTION_T
Definition: VhdlParserConstants.h:98
vhdl::parser::CONFIGURATION_T
const int CONFIGURATION_T
Definition: VhdlParserConstants.h:66
vhdl::parser::jjstrLiteralImages
static const JAVACC_STRING_TYPE jjstrLiteralImages[]
Definition: VhdlParserTokenManager.cc:239
vhdl::parser::VhdlParser::setLineParsed
static void setLineParsed(int tok)
Definition: vhdljjparser.cpp:723
vhdl::parser::ARCHITECTURE_T
const int ARCHITECTURE_T
Definition: VhdlParserConstants.h:40

Member Data Documentation

JAVACC_CHAR_TYPE vhdl::parser::VhdlParserTokenManager::curChar

Definition at line 130 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::curLexState

Definition at line 72 of file VhdlParserTokenManager.h.

FILE* vhdl::parser::VhdlParserTokenManager::debugStream

Debug output.

Definition at line 21 of file VhdlParserTokenManager.h.

TokenManagerErrorHandler* vhdl::parser::VhdlParserTokenManager::errorHandler

Definition at line 131 of file VhdlParserTokenManager.h.

bool vhdl::parser::VhdlParserTokenManager::errorHandlerCreated

Definition at line 132 of file VhdlParserTokenManager.h.

JAVACC_STRING_TYPE vhdl::parser::VhdlParserTokenManager::image

Definition at line 127 of file VhdlParserTokenManager.h.

JAVACC_CHARSTREAM* vhdl::parser::VhdlParserTokenManager::input_stream

Definition at line 123 of file VhdlParserTokenManager.h.

JAVACC_STRING_TYPE vhdl::parser::VhdlParserTokenManager::jjimage

Definition at line 126 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjimageLen

Definition at line 128 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjmatchedKind

Definition at line 76 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjmatchedPos

Definition at line 75 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjnewStateCnt

Definition at line 73 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjround

Definition at line 74 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjrounds[76]

Definition at line 124 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::jjstateSet[2 *76]

Definition at line 125 of file VhdlParserTokenManager.h.

int vhdl::parser::VhdlParserTokenManager::lengthOfMatch

Definition at line 129 of file VhdlParserTokenManager.h.

VhdlParser* vhdl::parser::VhdlParserTokenManager::parser
private

Definition at line 114 of file VhdlParserTokenManager.h.

The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.11