Regenerate checked in code with JavaCC 7.0.5

1 files changed, 474 insertions, 439 deletions

diff --git a/vhdlparser/VhdlParserTokenManager.cc b/vhdlparser/VhdlParserTokenManager.cc
index 2970785..aa56e43 100644
--- a/vhdlparser/VhdlParserTokenManager.cc
+++ b/vhdlparser/VhdlParserTokenManager.cc
@@ -13,232 +13,234 @@ static const unsigned long long jjbitVec3[] = {
    0x0ULL, 0x0ULL, 0xffffffff00000000ULL, 0xffffffffffffffffULL
 };
 static const int jjnextStates[] = {
-   58, 59, 60, 61, 62, 65, 69, 70, 71, 80, 21, 50, 51, 2, 37, 38, 
-   0, 3, 4, 5, 7, 12, 13, 15, 16, 24, 23, 25, 33, 34, 36, 39, 
-   40, 42, 46, 47, 49, 53, 54, 56, 60, 61, 62, 65, 64, 63, 65, 69, 
-   70, 71, 72, 73, 75, 9, 10, 28, 29, 27, 30, 
+   56, 57, 58, 59, 60, 63, 67, 68, 69, 78, 18, 19, 79, 81, 83, 48, 
+   49, 2, 35, 36, 0, 3, 4, 5, 7, 12, 13, 15, 16, 22, 21, 23, 
+   31, 32, 34, 37, 38, 40, 44, 45, 47, 51, 52, 54, 58, 59, 60, 63, 
+   62, 61, 63, 67, 68, 69, 70, 71, 73, 78, 18, 19, 78, 18, 19, 79, 
+   9, 10, 26, 27, 25, 28, 
 };
-static JAVACC_CHAR_TYPE jjstrLiteralChars_0[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_1[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_2[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_3[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_4[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_5[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_6[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_7[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_8[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_9[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_10[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_11[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_12[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_13[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_14[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_15[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_16[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_17[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_18[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_19[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_20[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_21[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_22[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_23[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_24[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_25[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_26[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_27[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_28[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_29[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_30[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_31[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_32[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_33[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_34[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_35[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_36[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_37[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_38[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_39[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_40[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_41[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_42[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_43[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_44[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_45[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_46[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_47[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_48[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_49[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_50[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_51[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_52[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_53[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_54[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_55[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_56[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_57[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_58[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_59[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_60[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_61[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_62[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_63[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_64[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_65[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_66[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_67[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_68[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_69[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_70[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_71[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_72[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_73[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_74[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_75[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_76[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_77[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_78[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_79[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_80[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_81[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_82[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_83[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_84[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_85[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_86[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_87[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_88[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_89[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_90[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_91[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_92[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_93[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_94[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_95[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_96[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_97[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_98[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_99[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_100[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_101[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_102[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_103[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_104[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_105[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_106[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_107[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_108[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_109[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_110[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_111[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_112[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_113[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_114[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_115[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_116[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_117[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_118[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_119[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_120[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_121[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_122[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_123[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_124[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_125[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_126[] = {0x26, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_127[] = {0x27, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_128[] = {0x28, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_129[] = {0x29, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_130[] = {0x2a, 0x2a, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_131[] = {0x2a, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_132[] = {0x2b, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_133[] = {0x2d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_134[] = {0x2c, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_135[] = {0x3a, 0x3d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_136[] = {0x3a, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_137[] = {0x3b, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_138[] = {0x3c, 0x3d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_139[] = {0x3e, 0x3d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_140[] = {0x3c, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_141[] = {0x3e, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_142[] = {0x3d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_143[] = {0x2f, 0x3d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_144[] = {0x3d, 0x3e, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_145[] = {0x3c, 0x3e, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_146[] = {0x3c, 0x3c, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_147[] = {0x3e, 0x3e, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_148[] = {0x3f, 0x3f, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_149[] = {0x3f, 0x3e, 0x3d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_150[] = {0x3f, 0x3c, 0x3d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_151[] = {0x3f, 0x3e, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_152[] = {0x3f, 0x3c, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_153[] = {0x3f, 0x3d, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_154[] = {0x3f, 0x2f, 0x3d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_155[] = {0x3f, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_156[] = {0x7c, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_157[] = {0x2e, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_158[] = {0x2f, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_159[] = {0x40, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_160[] = {0x5e, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_161[] = {0x5b, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_162[] = {0x5d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_163[] = {0x7b, 0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_164[] = {0x7d, 0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_165[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_166[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_167[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_168[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_169[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_170[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_171[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_172[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_173[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_174[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_175[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_176[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_177[] = {0};
-
-static JAVACC_CHAR_TYPE jjstrLiteralChars_178[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_179[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_180[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_181[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_182[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_183[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_184[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_185[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_186[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_187[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_188[] = {0};
-static JAVACC_CHAR_TYPE jjstrLiteralChars_189[] = {0};
-static const JAVACC_STRING_TYPE jjstrLiteralImages[] = {
+static JJChar jjstrLiteralChars_0[] = {0};
+static JJChar jjstrLiteralChars_1[] = {0};
+static JJChar jjstrLiteralChars_2[] = {0};
+static JJChar jjstrLiteralChars_3[] = {0};
+static JJChar jjstrLiteralChars_4[] = {0};
+static JJChar jjstrLiteralChars_5[] = {0};
+static JJChar jjstrLiteralChars_6[] = {0};
+
+static JJChar jjstrLiteralChars_7[] = {0};
+static JJChar jjstrLiteralChars_8[] = {0};
+static JJChar jjstrLiteralChars_9[] = {0};
+static JJChar jjstrLiteralChars_10[] = {0};
+static JJChar jjstrLiteralChars_11[] = {0};
+static JJChar jjstrLiteralChars_12[] = {0};
+static JJChar jjstrLiteralChars_13[] = {0};
+static JJChar jjstrLiteralChars_14[] = {0};
+static JJChar jjstrLiteralChars_15[] = {0};
+static JJChar jjstrLiteralChars_16[] = {0};
+static JJChar jjstrLiteralChars_17[] = {0};
+static JJChar jjstrLiteralChars_18[] = {0};
+static JJChar jjstrLiteralChars_19[] = {0};
+static JJChar jjstrLiteralChars_20[] = {0};
+
+static JJChar jjstrLiteralChars_21[] = {0};
+static JJChar jjstrLiteralChars_22[] = {0};
+static JJChar jjstrLiteralChars_23[] = {0};
+static JJChar jjstrLiteralChars_24[] = {0};
+static JJChar jjstrLiteralChars_25[] = {0};
+static JJChar jjstrLiteralChars_26[] = {0};
+static JJChar jjstrLiteralChars_27[] = {0};
+static JJChar jjstrLiteralChars_28[] = {0};
+static JJChar jjstrLiteralChars_29[] = {0};
+static JJChar jjstrLiteralChars_30[] = {0};
+static JJChar jjstrLiteralChars_31[] = {0};
+static JJChar jjstrLiteralChars_32[] = {0};
+static JJChar jjstrLiteralChars_33[] = {0};
+static JJChar jjstrLiteralChars_34[] = {0};
+
+static JJChar jjstrLiteralChars_35[] = {0};
+static JJChar jjstrLiteralChars_36[] = {0};
+static JJChar jjstrLiteralChars_37[] = {0};
+static JJChar jjstrLiteralChars_38[] = {0};
+static JJChar jjstrLiteralChars_39[] = {0};
+static JJChar jjstrLiteralChars_40[] = {0};
+static JJChar jjstrLiteralChars_41[] = {0};
+static JJChar jjstrLiteralChars_42[] = {0};
+static JJChar jjstrLiteralChars_43[] = {0};
+static JJChar jjstrLiteralChars_44[] = {0};
+static JJChar jjstrLiteralChars_45[] = {0};
+static JJChar jjstrLiteralChars_46[] = {0};
+static JJChar jjstrLiteralChars_47[] = {0};
+static JJChar jjstrLiteralChars_48[] = {0};
+
+static JJChar jjstrLiteralChars_49[] = {0};
+static JJChar jjstrLiteralChars_50[] = {0};
+static JJChar jjstrLiteralChars_51[] = {0};
+static JJChar jjstrLiteralChars_52[] = {0};
+static JJChar jjstrLiteralChars_53[] = {0};
+static JJChar jjstrLiteralChars_54[] = {0};
+static JJChar jjstrLiteralChars_55[] = {0};
+static JJChar jjstrLiteralChars_56[] = {0};
+static JJChar jjstrLiteralChars_57[] = {0};
+static JJChar jjstrLiteralChars_58[] = {0};
+static JJChar jjstrLiteralChars_59[] = {0};
+static JJChar jjstrLiteralChars_60[] = {0};
+static JJChar jjstrLiteralChars_61[] = {0};
+static JJChar jjstrLiteralChars_62[] = {0};
+
+static JJChar jjstrLiteralChars_63[] = {0};
+static JJChar jjstrLiteralChars_64[] = {0};
+static JJChar jjstrLiteralChars_65[] = {0};
+static JJChar jjstrLiteralChars_66[] = {0};
+static JJChar jjstrLiteralChars_67[] = {0};
+static JJChar jjstrLiteralChars_68[] = {0};
+static JJChar jjstrLiteralChars_69[] = {0};
+static JJChar jjstrLiteralChars_70[] = {0};
+static JJChar jjstrLiteralChars_71[] = {0};
+static JJChar jjstrLiteralChars_72[] = {0};
+static JJChar jjstrLiteralChars_73[] = {0};
+static JJChar jjstrLiteralChars_74[] = {0};
+static JJChar jjstrLiteralChars_75[] = {0};
+static JJChar jjstrLiteralChars_76[] = {0};
+
+static JJChar jjstrLiteralChars_77[] = {0};
+static JJChar jjstrLiteralChars_78[] = {0};
+static JJChar jjstrLiteralChars_79[] = {0};
+static JJChar jjstrLiteralChars_80[] = {0};
+static JJChar jjstrLiteralChars_81[] = {0};
+static JJChar jjstrLiteralChars_82[] = {0};
+static JJChar jjstrLiteralChars_83[] = {0};
+static JJChar jjstrLiteralChars_84[] = {0};
+static JJChar jjstrLiteralChars_85[] = {0};
+static JJChar jjstrLiteralChars_86[] = {0};
+static JJChar jjstrLiteralChars_87[] = {0};
+static JJChar jjstrLiteralChars_88[] = {0};
+static JJChar jjstrLiteralChars_89[] = {0};
+static JJChar jjstrLiteralChars_90[] = {0};
+
+static JJChar jjstrLiteralChars_91[] = {0};
+static JJChar jjstrLiteralChars_92[] = {0};
+static JJChar jjstrLiteralChars_93[] = {0};
+static JJChar jjstrLiteralChars_94[] = {0};
+static JJChar jjstrLiteralChars_95[] = {0};
+static JJChar jjstrLiteralChars_96[] = {0};
+static JJChar jjstrLiteralChars_97[] = {0};
+static JJChar jjstrLiteralChars_98[] = {0};
+static JJChar jjstrLiteralChars_99[] = {0};
+static JJChar jjstrLiteralChars_100[] = {0};
+static JJChar jjstrLiteralChars_101[] = {0};
+static JJChar jjstrLiteralChars_102[] = {0};
+static JJChar jjstrLiteralChars_103[] = {0};
+static JJChar jjstrLiteralChars_104[] = {0};
+
+static JJChar jjstrLiteralChars_105[] = {0};
+static JJChar jjstrLiteralChars_106[] = {0};
+static JJChar jjstrLiteralChars_107[] = {0};
+static JJChar jjstrLiteralChars_108[] = {0};
+static JJChar jjstrLiteralChars_109[] = {0};
+static JJChar jjstrLiteralChars_110[] = {0};
+static JJChar jjstrLiteralChars_111[] = {0};
+static JJChar jjstrLiteralChars_112[] = {0};
+static JJChar jjstrLiteralChars_113[] = {0};
+static JJChar jjstrLiteralChars_114[] = {0};
+static JJChar jjstrLiteralChars_115[] = {0};
+static JJChar jjstrLiteralChars_116[] = {0};
+static JJChar jjstrLiteralChars_117[] = {0};
+static JJChar jjstrLiteralChars_118[] = {0};
+
+static JJChar jjstrLiteralChars_119[] = {0};
+static JJChar jjstrLiteralChars_120[] = {0};
+static JJChar jjstrLiteralChars_121[] = {0};
+static JJChar jjstrLiteralChars_122[] = {0};
+static JJChar jjstrLiteralChars_123[] = {0};
+static JJChar jjstrLiteralChars_124[] = {0};
+static JJChar jjstrLiteralChars_125[] = {0};
+
+static JJChar jjstrLiteralChars_126[] = {0x26, 0};
+static JJChar jjstrLiteralChars_127[] = {0x27, 0};
+
+static JJChar jjstrLiteralChars_128[] = {0x28, 0};
+static JJChar jjstrLiteralChars_129[] = {0x29, 0};
+
+static JJChar jjstrLiteralChars_130[] = {0x2a, 0x2a, 0};
+static JJChar jjstrLiteralChars_131[] = {0x2a, 0};
+
+static JJChar jjstrLiteralChars_132[] = {0x2b, 0};
+static JJChar jjstrLiteralChars_133[] = {0x2d, 0};
+
+static JJChar jjstrLiteralChars_134[] = {0x2c, 0};
+static JJChar jjstrLiteralChars_135[] = {0x3a, 0x3d, 0};
+
+static JJChar jjstrLiteralChars_136[] = {0x3a, 0};
+static JJChar jjstrLiteralChars_137[] = {0x3b, 0};
+
+static JJChar jjstrLiteralChars_138[] = {0x3c, 0x3d, 0};
+static JJChar jjstrLiteralChars_139[] = {0x3e, 0x3d, 0};
+
+static JJChar jjstrLiteralChars_140[] = {0x3c, 0};
+static JJChar jjstrLiteralChars_141[] = {0x3e, 0};
+
+static JJChar jjstrLiteralChars_142[] = {0x3d, 0};
+static JJChar jjstrLiteralChars_143[] = {0x2f, 0x3d, 0};
+
+static JJChar jjstrLiteralChars_144[] = {0x3d, 0x3e, 0};
+static JJChar jjstrLiteralChars_145[] = {0x3c, 0x3e, 0};
+
+static JJChar jjstrLiteralChars_146[] = {0x3c, 0x3c, 0};
+static JJChar jjstrLiteralChars_147[] = {0x3e, 0x3e, 0};
+
+static JJChar jjstrLiteralChars_148[] = {0x3f, 0x3f, 0};
+static JJChar jjstrLiteralChars_149[] = {0x3f, 0x3e, 0x3d, 0};
+
+static JJChar jjstrLiteralChars_150[] = {0x3f, 0x3c, 0x3d, 0};
+static JJChar jjstrLiteralChars_151[] = {0x3f, 0x3e, 0};
+
+static JJChar jjstrLiteralChars_152[] = {0x3f, 0x3c, 0};
+static JJChar jjstrLiteralChars_153[] = {0x3f, 0x3d, 0};
+
+static JJChar jjstrLiteralChars_154[] = {0x3f, 0x2f, 0x3d, 0};
+static JJChar jjstrLiteralChars_155[] = {0x3f, 0};
+
+static JJChar jjstrLiteralChars_156[] = {0x7c, 0};
+static JJChar jjstrLiteralChars_157[] = {0x2e, 0};
+
+static JJChar jjstrLiteralChars_158[] = {0x2f, 0};
+static JJChar jjstrLiteralChars_159[] = {0x40, 0};
+
+static JJChar jjstrLiteralChars_160[] = {0x5e, 0};
+static JJChar jjstrLiteralChars_161[] = {0x5b, 0};
+
+static JJChar jjstrLiteralChars_162[] = {0x5d, 0};
+static JJChar jjstrLiteralChars_163[] = {0x7b, 0};
+
+static JJChar jjstrLiteralChars_164[] = {0x7d, 0};
+static JJChar jjstrLiteralChars_165[] = {0};
+static JJChar jjstrLiteralChars_166[] = {0};
+static JJChar jjstrLiteralChars_167[] = {0};
+static JJChar jjstrLiteralChars_168[] = {0};
+static JJChar jjstrLiteralChars_169[] = {0};
+static JJChar jjstrLiteralChars_170[] = {0};
+static JJChar jjstrLiteralChars_171[] = {0};
+static JJChar jjstrLiteralChars_172[] = {0};
+static JJChar jjstrLiteralChars_173[] = {0};
+static JJChar jjstrLiteralChars_174[] = {0};
+static JJChar jjstrLiteralChars_175[] = {0};
+static JJChar jjstrLiteralChars_176[] = {0};
+static JJChar jjstrLiteralChars_177[] = {0};
+
+static JJChar jjstrLiteralChars_178[] = {0};
+static JJChar jjstrLiteralChars_179[] = {0};
+static JJChar jjstrLiteralChars_180[] = {0};
+static JJChar jjstrLiteralChars_181[] = {0};
+static JJChar jjstrLiteralChars_182[] = {0};
+static JJChar jjstrLiteralChars_183[] = {0};
+static JJChar jjstrLiteralChars_184[] = {0};
+static JJChar jjstrLiteralChars_185[] = {0};
+static JJChar jjstrLiteralChars_186[] = {0};
+static JJChar jjstrLiteralChars_187[] = {0};
+static JJChar jjstrLiteralChars_188[] = {0};
+static JJChar jjstrLiteralChars_189[] = {0};
+static JJChar jjstrLiteralChars_190[] = {0};
+static const JJString jjstrLiteralImages[] = {
 jjstrLiteralChars_0, 
 jjstrLiteralChars_1, 
 jjstrLiteralChars_2, 
@@ -429,22 +431,23 @@ jjstrLiteralChars_186,
 jjstrLiteralChars_187, 
 jjstrLiteralChars_188, 
 jjstrLiteralChars_189, 
+jjstrLiteralChars_190, 
 };
 
 /** Lexer state names. */
-static const JAVACC_CHAR_TYPE lexStateNames_arr_0[] = 
+static const JJChar lexStateNames_arr_0[] = 
 {0x44, 0x45, 0x46, 0x41, 0x55, 0x4c, 0x54, 0};
-static const JAVACC_STRING_TYPE lexStateNames[] = {
+static const JJString lexStateNames[] = {
 lexStateNames_arr_0, 
 };
 static const unsigned long long jjtoToken[] = {
-   0xfffffffffffff801ULL, 0xffffffffffffffffULL, 0x20101fffffffffffULL, 
+   0xfffffffffffff801ULL, 0xffffffffffffffffULL, 0x60101fffffffffffULL, 
 };
 static const unsigned long long jjtoSkip[] = {
    0x7deULL, 0x0ULL, 0x0ULL, 
 };
 
-void  VhdlParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; }
+  void  VhdlParserTokenManager::setDebugStream(FILE *ds){ debugStream = ds; }
 
  int  VhdlParserTokenManager::jjStopAtPos(int pos, int kind){
    jjmatchedKind = kind;
@@ -2687,7 +2690,7 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
    curChar = input_stream->readChar();
    curPos = 0;
    int startsAt = 0;
-   jjnewStateCnt = 81;
+   jjnewStateCnt = 87;
    int i = 1;
    jjstateSet[0] = startState;
    int kind = 0x7fffffff;
@@ -2708,23 +2711,23 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                   {
                      if (kind > 165)
                         kind = 165;
-                     { jjCheckNAddStates(0, 10); }
+                     { jjCheckNAddStates(0, 12); }
                   }
                   else if ((0x100000200ULL & l) != 0L)
                      { jjCheckNAddTwoStates(0, 3); }
+                  else if (curChar == 39)
+                     { jjAddStates(13, 14); }
                   else if (curChar == 47)
-                     { jjAddStates(11, 12); }
+                     { jjAddStates(15, 16); }
                   else if (curChar == 45)
-                     { jjCheckNAddStates(13, 15); }
-                  else if (curChar == 39)
-                     jjstateSet[jjnewStateCnt++] = 18;
+                     { jjCheckNAddStates(17, 19); }
                   else if (curChar == 34)
                      { jjCheckNAddTwoStates(9, 10); }
                   if ((0x3ff000000000000ULL & l) != 0L)
                   {
                      if (kind > 171)
                         kind = 171;
-                     { jjCheckNAdd(20); }
+                     { jjCheckNAdd(17); }
                   }
                   break;
                case 0:
@@ -2736,7 +2739,7 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                      break;
                   if (kind > 6)
                      kind = 6;
-                  { jjCheckNAddStates(16, 20); }
+                  { jjCheckNAddStates(20, 24); }
                   break;
                case 2:
                   if (curChar == 45)
@@ -2751,7 +2754,7 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                      break;
                   if (kind > 6)
                      kind = 6;
-                  { jjCheckNAddStates(16, 20); }
+                  { jjCheckNAddStates(20, 24); }
                   break;
                case 5:
                   if ((0x2400ULL & l) == 0L)
@@ -2791,265 +2794,285 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                      break;
                   if (kind > 167)
                      kind = 167;
-                  { jjAddStates(21, 22); }
+                  { jjAddStates(25, 26); }
                   break;
                case 15:
                   if ((0xfffffffb00000200ULL & l) != 0L)
-                     { jjAddStates(23, 24); }
+                     { jjAddStates(27, 28); }
                   break;
                case 17:
-                  if (curChar == 39)
-                     jjstateSet[jjnewStateCnt++] = 18;
-                  break;
-               case 18:
-                  if ((0xffffffff00000200ULL & l) != 0L)
-                     jjstateSet[jjnewStateCnt++] = 19;
-                  break;
-               case 19:
-                  if (curChar == 39 && kind > 169)
-                     kind = 169;
-                  break;
-               case 20:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 171)
                      kind = 171;
-                  { jjCheckNAdd(20); }
+                  { jjCheckNAdd(17); }
                   break;
-               case 22:
+               case 20:
                   if (curChar == 34)
-                     { jjCheckNAdd(23); }
+                     { jjCheckNAdd(21); }
                   break;
-               case 23:
+               case 21:
                   if ((0x3ff200000000000ULL & l) != 0L)
-                     { jjCheckNAddStates(25, 27); }
+                     { jjCheckNAddStates(29, 31); }
                   break;
-               case 25:
+               case 23:
                   if (curChar == 34 && kind > 180)
                      kind = 180;
                   break;
-               case 27:
+               case 25:
                   if (curChar == 34)
-                     { jjCheckNAddTwoStates(28, 29); }
+                     { jjCheckNAddTwoStates(26, 27); }
                   break;
-               case 28:
+               case 26:
                   if ((0xfffffffb00000200ULL & l) != 0L)
-                     { jjCheckNAddTwoStates(28, 29); }
+                     { jjCheckNAddTwoStates(26, 27); }
                   break;
-               case 29:
+               case 27:
                   if (curChar != 34)
                      break;
                   if (kind > 189)
                      kind = 189;
-                  { jjCheckNAddTwoStates(27, 30); }
+                  { jjCheckNAddTwoStates(25, 28); }
                   break;
-               case 30:
+               case 28:
                   if ((0xfffffffb00000200ULL & l) == 0L)
                      break;
                   if (kind > 189)
                      kind = 189;
-                  { jjCheckNAddTwoStates(27, 30); }
+                  { jjCheckNAddTwoStates(25, 28); }
                   break;
-               case 31:
+               case 29:
                   if (curChar == 45)
-                     { jjCheckNAddStates(13, 15); }
+                     { jjCheckNAddStates(17, 19); }
                   break;
-               case 32:
+               case 30:
                   if (curChar != 35)
                      break;
                   if (kind > 7)
                      kind = 7;
-                  { jjCheckNAddStates(28, 30); }
+                  { jjCheckNAddStates(32, 34); }
                   break;
-               case 33:
+               case 31:
                   if ((0xffffffffffffdbffULL & l) == 0L)
                      break;
                   if (kind > 7)
                      kind = 7;
-                  { jjCheckNAddStates(28, 30); }
+                  { jjCheckNAddStates(32, 34); }
                   break;
-               case 34:
+               case 32:
                   if ((0x2400ULL & l) != 0L && kind > 7)
                      kind = 7;
                   break;
-               case 35:
+               case 33:
                   if (curChar == 10 && kind > 7)
                      kind = 7;
                   break;
-               case 36:
+               case 34:
                   if (curChar == 13)
-                     jjstateSet[jjnewStateCnt++] = 35;
+                     jjstateSet[jjnewStateCnt++] = 33;
                   break;
-               case 37:
+               case 35:
                   if (curChar == 45)
-                     jjstateSet[jjnewStateCnt++] = 32;
+                     jjstateSet[jjnewStateCnt++] = 30;
                   break;
-               case 38:
+               case 36:
                   if (curChar != 45)
                      break;
                   if (kind > 8)
                      kind = 8;
-                  { jjCheckNAddStates(31, 33); }
+                  { jjCheckNAddStates(35, 37); }
                   break;
-               case 39:
+               case 37:
                   if ((0xffffffffffffdbffULL & l) == 0L)
                      break;
                   if (kind > 8)
                      kind = 8;
-                  { jjCheckNAddStates(31, 33); }
+                  { jjCheckNAddStates(35, 37); }
                   break;
-               case 40:
+               case 38:
                   if ((0x2400ULL & l) != 0L && kind > 8)
                      kind = 8;
                   break;
-               case 41:
+               case 39:
                   if (curChar == 10 && kind > 8)
                      kind = 8;
                   break;
-               case 42:
+               case 40:
                   if (curChar == 13)
-                     jjstateSet[jjnewStateCnt++] = 41;
+                     jjstateSet[jjnewStateCnt++] = 39;
                   break;
-               case 43:
+               case 41:
                   if (curChar == 47)
-                     { jjAddStates(11, 12); }
+                     { jjAddStates(15, 16); }
                   break;
-               case 44:
+               case 42:
                   if (curChar == 33)
-                     { jjCheckNAddTwoStates(45, 46); }
+                     { jjCheckNAddTwoStates(43, 44); }
                   break;
-               case 45:
+               case 43:
                   if ((0xfffffbffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(45, 46); }
+                     { jjCheckNAddTwoStates(43, 44); }
                   break;
-               case 46:
+               case 44:
                   if (curChar == 42)
-                     { jjCheckNAddStates(34, 36); }
+                     { jjCheckNAddStates(38, 40); }
                   break;
-               case 47:
+               case 45:
                   if ((0xffff7bffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(48, 46); }
+                     { jjCheckNAddTwoStates(46, 44); }
                   break;
-               case 48:
+               case 46:
                   if ((0xfffffbffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(48, 46); }
+                     { jjCheckNAddTwoStates(46, 44); }
                   break;
-               case 49:
+               case 47:
                   if (curChar == 47 && kind > 9)
                      kind = 9;
                   break;
-               case 50:
+               case 48:
                   if (curChar == 42)
-                     jjstateSet[jjnewStateCnt++] = 44;
+                     jjstateSet[jjnewStateCnt++] = 42;
                   break;
-               case 51:
+               case 49:
                   if (curChar == 42)
-                     { jjCheckNAddTwoStates(52, 53); }
+                     { jjCheckNAddTwoStates(50, 51); }
                   break;
-               case 52:
+               case 50:
                   if ((0xfffffbffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(52, 53); }
+                     { jjCheckNAddTwoStates(50, 51); }
                   break;
-               case 53:
+               case 51:
                   if (curChar == 42)
-                     { jjCheckNAddStates(37, 39); }
+                     { jjCheckNAddStates(41, 43); }
                   break;
-               case 54:
+               case 52:
                   if ((0xffff7bffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(55, 53); }
+                     { jjCheckNAddTwoStates(53, 51); }
                   break;
-               case 55:
+               case 53:
                   if ((0xfffffbffffffffffULL & l) != 0L)
-                     { jjCheckNAddTwoStates(55, 53); }
+                     { jjCheckNAddTwoStates(53, 51); }
                   break;
-               case 56:
+               case 54:
                   if (curChar == 47 && kind > 10)
                      kind = 10;
                   break;
-               case 57:
+               case 55:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 165)
                      kind = 165;
-                  { jjCheckNAddStates(0, 10); }
+                  { jjCheckNAddStates(0, 12); }
                   break;
-               case 59:
+               case 57:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 165)
                      kind = 165;
-                  { jjCheckNAddTwoStates(58, 59); }
+                  { jjCheckNAddTwoStates(56, 57); }
                   break;
-               case 61:
+               case 59:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 170)
                      kind = 170;
-                  { jjCheckNAddStates(40, 43); }
+                  { jjCheckNAddStates(44, 47); }
                   break;
-               case 62:
+               case 60:
                   if (curChar == 46)
-                     { jjCheckNAdd(63); }
+                     { jjCheckNAdd(61); }
                   break;
-               case 63:
+               case 61:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 170)
                      kind = 170;
-                  { jjCheckNAddStates(44, 46); }
+                  { jjCheckNAddStates(48, 50); }
                   break;
-               case 66:
+               case 64:
                   if ((0x280000000000ULL & l) != 0L)
-                     { jjCheckNAdd(67); }
+                     { jjCheckNAdd(65); }
                   break;
-               case 67:
+               case 65:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 170)
                      kind = 170;
-                  { jjCheckNAddTwoStates(68, 67); }
+                  { jjCheckNAddTwoStates(66, 65); }
                   break;
-               case 70:
+               case 68:
                   if ((0x3ff000000000000ULL & l) != 0L)
-                     { jjCheckNAddStates(47, 49); }
+                     { jjCheckNAddStates(51, 53); }
                   break;
-               case 71:
+               case 69:
                   if (curChar == 35)
-                     { jjCheckNAdd(72); }
+                     { jjCheckNAdd(70); }
                   break;
-               case 72:
+               case 70:
                   if ((0x3ff000000000000ULL & l) != 0L)
-                     { jjCheckNAddStates(50, 52); }
+                     { jjCheckNAddStates(54, 56); }
                   break;
-               case 73:
+               case 71:
                   if (curChar == 46)
-                     { jjCheckNAdd(74); }
+                     { jjCheckNAdd(72); }
                   break;
-               case 74:
+               case 72:
                   if ((0x3ff000000000000ULL & l) != 0L)
-                     { jjCheckNAddTwoStates(74, 75); }
+                     { jjCheckNAddTwoStates(72, 73); }
                   break;
-               case 75:
+               case 73:
                   if (curChar != 35)
                      break;
                   if (kind > 172)
                      kind = 172;
-                  jjstateSet[jjnewStateCnt++] = 76;
+                  jjstateSet[jjnewStateCnt++] = 74;
                   break;
-               case 77:
+               case 75:
                   if ((0x280000000000ULL & l) != 0L)
-                     { jjCheckNAdd(78); }
+                     { jjCheckNAdd(76); }
                   break;
-               case 78:
+               case 76:
                   if ((0x3ff000000000000ULL & l) == 0L)
                      break;
                   if (kind > 172)
                      kind = 172;
-                  { jjCheckNAddTwoStates(79, 78); }
+                  { jjCheckNAddTwoStates(77, 76); }
                   break;
-               case 80:
+               case 78:
                   if ((0x3ff000000000000ULL & l) != 0L)
-                     { jjCheckNAddTwoStates(80, 21); }
+                     { jjCheckNAddStates(57, 59); }
+                  break;
+               case 79:
+                  if ((0x3ff000000000000ULL & l) != 0L)
+                     { jjCheckNAddStates(60, 63); }
+                  break;
+               case 80:
+                  if (curChar == 39)
+                     { jjAddStates(13, 14); }
+                  break;
+               case 81:
+                  if ((0xffffffff00000200ULL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 82;
+                  break;
+               case 82:
+                  if (curChar == 39 && kind > 169)
+                     kind = 169;
+                  break;
+               case 83:
+                  if (curChar == 40)
+                     jjstateSet[jjnewStateCnt++] = 84;
+                  break;
+               case 84:
+                  if (curChar == 39)
+                     jjstateSet[jjnewStateCnt++] = 85;
+                  break;
+               case 85:
+                  if ((0xfffffffb00000200ULL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 86;
+                  break;
+               case 86:
+                  if (curChar == 39 && kind > 190)
+                     kind = 190;
                   break;
                default : break;
             }
@@ -3068,10 +3091,10 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                   {
                      if (kind > 171)
                         kind = 171;
-                     { jjCheckNAdd(20); }
+                     { jjCheckNAdd(17); }
                   }
                   else if (curChar == 96)
-                     { jjCheckNAddTwoStates(27, 30); }
+                     { jjCheckNAddTwoStates(25, 28); }
                   else if (curChar == 92)
                      { jjCheckNAddTwoStates(15, 16); }
                   if ((0x7fffffe07fffffeULL & l) != 0L)
@@ -3081,16 +3104,18 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                      { jjCheckNAddTwoStates(12, 13); }
                   }
                   if ((0x100801401008014ULL & l) != 0L)
-                     jjstateSet[jjnewStateCnt++] = 22;
+                     jjstateSet[jjnewStateCnt++] = 20;
+                  else if ((0x280000ULL & l) != 0L)
+                     { jjCheckNAddTwoStates(18, 19); }
                   break;
                case 4:
                   if (kind > 6)
                      kind = 6;
-                  { jjAddStates(16, 20); }
+                  { jjAddStates(20, 24); }
                   break;
                case 9:
                   if ((0x7fffffffffffffffULL & l) != 0L)
-                     { jjAddStates(53, 54); }
+                     { jjAddStates(64, 65); }
                   break;
                case 12:
                   if (curChar == 95)
@@ -3115,107 +3140,115 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                   if (curChar == 92 && kind > 168)
                      kind = 168;
                   break;
-               case 18:
-                  if ((0x7fffffffffffffffULL & l) != 0L)
-                     jjstateSet[jjnewStateCnt++] = 19;
-                  break;
-               case 20:
+               case 17:
                   if ((0x7fffffe07fffffeULL & l) == 0L)
                      break;
                   if (kind > 171)
                      kind = 171;
-                  { jjCheckNAdd(20); }
+                  { jjCheckNAdd(17); }
                   break;
-               case 21:
+               case 18:
+                  if ((0x280000ULL & l) != 0L)
+                     { jjCheckNAddTwoStates(18, 19); }
+                  break;
+               case 19:
                   if ((0x100801401008014ULL & l) != 0L)
-                     jjstateSet[jjnewStateCnt++] = 22;
+                     jjstateSet[jjnewStateCnt++] = 20;
                   break;
-               case 23:
+               case 21:
                   if ((0x7fffffe07fffffeULL & l) != 0L)
-                     { jjCheckNAddStates(25, 27); }
+                     { jjCheckNAddStates(29, 31); }
                   break;
-               case 24:
+               case 22:
                   if (curChar == 95)
-                     { jjCheckNAddTwoStates(24, 23); }
+                     { jjCheckNAddTwoStates(22, 21); }
                   break;
-               case 26:
+               case 24:
                   if (curChar == 96)
-                     { jjCheckNAddTwoStates(27, 30); }
+                     { jjCheckNAddTwoStates(25, 28); }
                   break;
-               case 28:
+               case 26:
                   if ((0x7fffffffffffffffULL & l) != 0L)
-                     { jjAddStates(55, 56); }
+                     { jjAddStates(66, 67); }
                   break;
-               case 30:
+               case 28:
                   if ((0x7fffffffffffffffULL & l) == 0L)
                      break;
                   if (kind > 189)
                      kind = 189;
-                  { jjCheckNAddTwoStates(27, 30); }
+                  { jjCheckNAddTwoStates(25, 28); }
                   break;
-               case 33:
+               case 31:
                   if (kind > 7)
                      kind = 7;
-                  { jjAddStates(28, 30); }
+                  { jjAddStates(32, 34); }
                   break;
-               case 39:
+               case 37:
                   if (kind > 8)
                      kind = 8;
-                  { jjAddStates(31, 33); }
+                  { jjAddStates(35, 37); }
+                  break;
+               case 43:
+                  { jjCheckNAddTwoStates(43, 44); }
                   break;
                case 45:
-                  { jjCheckNAddTwoStates(45, 46); }
+               case 46:
+                  { jjCheckNAddTwoStates(46, 44); }
                   break;
-               case 47:
-               case 48:
-                  { jjCheckNAddTwoStates(48, 46); }
+               case 50:
+                  { jjCheckNAddTwoStates(50, 51); }
                   break;
                case 52:
-                  { jjCheckNAddTwoStates(52, 53); }
+               case 53:
+                  { jjCheckNAddTwoStates(53, 51); }
                   break;
-               case 54:
-               case 55:
-                  { jjCheckNAddTwoStates(55, 53); }
+               case 56:
+                  if (curChar == 95)
+                     jjstateSet[jjnewStateCnt++] = 57;
                   break;
                case 58:
                   if (curChar == 95)
                      jjstateSet[jjnewStateCnt++] = 59;
                   break;
-               case 60:
+               case 62:
                   if (curChar == 95)
                      jjstateSet[jjnewStateCnt++] = 61;
                   break;
-               case 64:
-                  if (curChar == 95)
-                     jjstateSet[jjnewStateCnt++] = 63;
-                  break;
-               case 65:
+               case 63:
                   if ((0x2000000020ULL & l) != 0L)
-                     { jjCheckNAddTwoStates(66, 67); }
+                     { jjCheckNAddTwoStates(64, 65); }
                   break;
-               case 68:
+               case 66:
                   if (curChar == 95)
-                     { jjCheckNAdd(67); }
+                     { jjCheckNAdd(65); }
                   break;
-               case 69:
+               case 67:
                   if (curChar == 95)
-                     jjstateSet[jjnewStateCnt++] = 70;
+                     jjstateSet[jjnewStateCnt++] = 68;
                   break;
-               case 72:
+               case 70:
                   if ((0x7fffffe07fffffeULL & l) != 0L)
-                     { jjCheckNAddStates(50, 52); }
+                     { jjCheckNAddStates(54, 56); }
                   break;
-               case 74:
+               case 72:
                   if ((0x7fffffe07fffffeULL & l) != 0L)
-                     { jjCheckNAddTwoStates(74, 75); }
+                     { jjCheckNAddTwoStates(72, 73); }
                   break;
-               case 76:
+               case 74:
                   if ((0x2000000020ULL & l) != 0L)
-                     { jjCheckNAddTwoStates(77, 78); }
+                     { jjCheckNAddTwoStates(75, 76); }
                   break;
-               case 79:
+               case 77:
                   if (curChar == 95)
-                     { jjCheckNAdd(78); }
+                     { jjCheckNAdd(76); }
+                  break;
+               case 81:
+                  if ((0x7fffffffffffffffULL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 82;
+                  break;
+               case 85:
+                  if ((0x7fffffffffffffffULL & l) != 0L)
+                     jjstateSet[jjnewStateCnt++] = 86;
                   break;
                default : break;
             }
@@ -3237,62 +3270,66 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
                      break;
                   if (kind > 6)
                      kind = 6;
-                  { jjAddStates(16, 20); }
+                  { jjAddStates(20, 24); }
                   break;
                case 9:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjAddStates(53, 54); }
+                     { jjAddStates(64, 65); }
                   break;
                case 15:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjAddStates(23, 24); }
+                     { jjAddStates(27, 28); }
                   break;
-               case 18:
+               case 26:
                   if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     jjstateSet[jjnewStateCnt++] = 19;
+                     { jjAddStates(66, 67); }
                   break;
                case 28:
-                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
-                     { jjAddStates(55, 56); }
-                  break;
-               case 30:
                   if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
                      break;
                   if (kind > 189)
                      kind = 189;
-                  { jjAddStates(57, 58); }
+                  { jjAddStates(68, 69); }
                   break;
-               case 33:
+               case 31:
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                      break;
                   if (kind > 7)
                      kind = 7;
-                  { jjAddStates(28, 30); }
+                  { jjAddStates(32, 34); }
                   break;
-               case 39:
+               case 37:
                   if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
                      break;
                   if (kind > 8)
                      kind = 8;
-                  { jjAddStates(31, 33); }
+                  { jjAddStates(35, 37); }
+                  break;
+               case 43:
+                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
+                     { jjCheckNAddTwoStates(43, 44); }
                   break;
                case 45:
+               case 46:
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(45, 46); }
+                     { jjCheckNAddTwoStates(46, 44); }
                   break;
-               case 47:
-               case 48:
+               case 50:
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(48, 46); }
+                     { jjCheckNAddTwoStates(50, 51); }
                   break;
                case 52:
+               case 53:
                   if (jjCanMove_0(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(52, 53); }
+                     { jjCheckNAddTwoStates(53, 51); }
                   break;
-               case 54:
-               case 55:
-                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
-                     { jjCheckNAddTwoStates(55, 53); }
+               case 81:
+                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
+                     jjstateSet[jjnewStateCnt++] = 82;
+                  break;
+               case 85:
+                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
+                     jjstateSet[jjnewStateCnt++] = 86;
                   break;
                default : if (i1 == 0 || l1 == 0 || i2 == 0 ||  l2 == 0) break; else break;
             }
@@ -3305,7 +3342,7 @@ int VhdlParserTokenManager::jjMoveNfa_0(int startState, int curPos){
          kind = 0x7fffffff;
       }
       ++curPos;
-      if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 81 - startsAt)))
+      if ((i = jjnewStateCnt), (jjnewStateCnt = startsAt), (i == (startsAt = 87 - startsAt)))
          break;
       if (input_stream->endOfInput()) { break; }
       curChar = input_stream->readChar();
@@ -3357,12 +3394,12 @@ bool VhdlParserTokenManager::jjCanMove_1(int hiByte, int i1, int i2, unsigned lo
 
 Token * VhdlParserTokenManager::jjFillToken(){
    Token *t;
-   JAVACC_STRING_TYPE curTokenImage;
+   JJString curTokenImage;
    int beginLine   = -1;
    int endLine     = -1;
    int beginColumn = -1;
    int endColumn   = -1;
-   JAVACC_STRING_TYPE im = jjstrLiteralImages[jjmatchedKind];
+   JJString im = jjstrLiteralImages[jjmatchedKind];
    curTokenImage = (im.length() == 0) ? input_stream->GetImage() : im;
    if (input_stream->getTrackLineColumn()) {
      beginLine = input_stream->getBeginLine();
@@ -3373,8 +3410,8 @@ Token * VhdlParserTokenManager::jjFillToken(){
    t = Token::newToken(jjmatchedKind);
    t->kind = jjmatchedKind;
    t->image = curTokenImage;
-   t->specialToken = NULL;
-   t->next = NULL;
+   t->specialToken = nullptr;
+   t->next = nullptr;
 
    if (input_stream->getTrackLineColumn()) {
    t->beginLine = beginLine;
@@ -3389,7 +3426,7 @@ const int defaultLexState = 0;
 /** Get the next Token. */
 
 Token * VhdlParserTokenManager::getNextToken(){
-  Token *matchedToken;
+  Token *matchedToken = nullptr;
   int curPos = 0;
 
   for (;;)
@@ -3422,13 +3459,13 @@ Token * VhdlParserTokenManager::getNextToken(){
       }
       else
       {
-         SkipLexicalActions(NULL);
+         SkipLexicalActions(nullptr);
          goto EOFLoop;
       }
    }
    int error_line = input_stream->getEndLine();
    int error_column = input_stream->getEndColumn();
-   JAVACC_STRING_TYPE error_after;
+   JJString error_after;
    bool EOFSeen = false;
    if (input_stream->endOfInput()) {
       EOFSeen = true;
@@ -3627,7 +3664,7 @@ void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
    }
 }
   /** Reinitialise parser. */
-  void VhdlParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState, VhdlParser *parserArg) {
+  void VhdlParserTokenManager::ReInit(JAVACC_CHARSTREAM *stream, int lexState) {
     clear();
     jjmatchedPos = jjnewStateCnt = 0;
     curLexState = lexState;
@@ -3635,22 +3672,20 @@ void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
     ReInitRounds();
     debugStream = stdout; // init
     SwitchTo(lexState);
-    parser = parserArg;
     errorHandler = new TokenManagerErrorHandler();
-    errorHandlerCreated = true;
   }
 
   void VhdlParserTokenManager::ReInitRounds() {
     int i;
     jjround = 0x80000001;
-    for (i = 81; i-- > 0;)
+    for (i = 87; i-- > 0;)
       jjrounds[i] = 0x80000000;
   }
 
   /** Switch to specified lex state. */
   void VhdlParserTokenManager::SwitchTo(int lexState) {
     if (lexState >= 1 || lexState < 0) {
-      JAVACC_STRING_TYPE message;
+      JJString message;
 #ifdef WIDE_CHAR
       message += L"Error: Ignoring invalid lexical state : ";
       message += lexState; message += L". State unchanged.";
@@ -3664,11 +3699,11 @@ void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
   }
 
   /** Constructor. */
-  VhdlParserTokenManager::VhdlParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState, VhdlParser *parserArg)
+  VhdlParserTokenManager::VhdlParserTokenManager (JAVACC_CHARSTREAM *stream, int lexState)
+  : TokenParser()
   {
-    input_stream = NULL;
-    errorHandlerCreated = false;
-    ReInit(stream, lexState, parserArg);
+    input_stream = nullptr;
+    ReInit(stream, lexState);
   }
 
   // Destructor
@@ -3681,7 +3716,7 @@ void  VhdlParserTokenManager::TokenLexicalActions(Token *matchedToken){
     //Since input_stream was generated outside of TokenManager
     //TokenManager should not take care of deleting it
     //if (input_stream) delete input_stream;
-    if (errorHandlerCreated) delete errorHandler;    
+    if (errorHandler) delete errorHandler, errorHandler = nullptr;    
   }