1 /* VhdlParser.cc */
2 #include "VhdlParser.h"
3 #include "TokenMgrError.h"
4 namespace vhdl {
5 namespace parser {
6   unsigned int jj_la1_0[] = {
7 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x90404000,0x20080000,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x90004000,0x400000,0x0,0x90404000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20080000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x40000000,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x40020000,0x40020001,0x0,0x0,0x0,0x40000000,0xd0020000,0x0,0x0,0x800000,0x0,0x0,0x80004000,0x400000,0x0,0x0,0x80404000,0x0,0x0,0x0,0x0,0x8000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x10800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10800,0x10000000,0x0,0x50000000,0x8000,0x80000000,0x0,0x80000000,0x80000000,0x4000000,0x8000000,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x800,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x80004000,0x0,0x80004000,0x0,0x0,0x0,0x0,0x0,0x0,0x90004000,0x400000,0x0,0x0,0x90404000,0x0,0x0,0x0,0x40000000,0x0,0x0,0x80004000,0x400000,0x0,0x80404000,0x0,0x0,0x0,0x0,0x0,0x0,0x20080000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10800,0x0,0x0,0x20000,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x8000000,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80004000,0x400000,0x0,0x80404000,0x0,0x0,0x0,0x0,0x0,0x0,0x20080000,0x0,0x8000,0x0,0x0,0x41000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10800,0x2000,0x0,0x80004000,0x400000,0x0,0x80404000,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x90c04000,0x20080000,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
8   unsigned int jj_la1_1[] = {
9 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x125808,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x0,0x1000,0x104800,0x1008,0x20000,0x125808,0x10000,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x1000,0x1000000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x20000,0x1000,0x0,0x4000000,0x1,0x0,0x400000,0x4000101,0x4000101,0x0,0x10,0x0,0x100,0x12024900,0x0,0x0,0x0,0x100,0x0,0x104800,0x8,0x20000,0x0,0x124808,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x200000,0x0,0x0,0x0,0x81000,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x800,0x0,0x0,0x0,0x8a00000,0x0,0x0,0x1000,0x0,0x0,0x0,0x1000,0x0,0x0,0x8a00000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x40000,0x400000,0x0,0x0,0x104800,0x20000,0x124800,0x10000,0x10000,0x0,0x0,0x10000,0x10000,0x104800,0x8,0x20000,0x0,0x124808,0x0,0x0,0x0,0x100,0x1,0x0,0x104800,0x0,0x20000,0x124800,0x0,0x0,0x0,0x1000000,0x0,0x0,0x20081200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x104000,0x1000000,0x1104800,0x0,0x20000,0x1124800,0x4000,0x0,0x100000,0x100000,0x0,0x104000,0x20081200,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x1104800,0x0,0x20000,0x1124800,0x0,0x104000,0x104000,0x0,0x4000001,0x1,0x0,0x4000001,0x10000,0x10000,0x10000,0x0,0x0,0x125808,0x0,0x20,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x20,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x200000,0x0,0x0,0x0,0x200000,0x0,0x20,0x104000,0x100000,0x100000,0x0,0x1000000,0x0,0x0,0x104000,};
10   unsigned int jj_la1_2[] = {
11 0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x110000,0x28000,0x0,0x20000000,0x0,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x4000,0x0,0x0,0x110000,0x0,0x0,0x110000,0x0,0x4000,0x4000,0x0,0x0,0x0,0x0,0x28000,0x0,0x0,0x0,0x0,0x400,0x0,0x4000,0x0,0x0,0x0,0x4000,0x0,0x4000,0x400000,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x1000,0x1000,0x0,0x0,0x0,0x100,0x11000,0x0,0x0,0x0,0x0,0x0,0x110000,0x0,0x0,0x1000,0x111000,0x0,0x0,0x4000,0x0,0x400,0x8000,0x28000,0x0,0x0,0x0,0x0,0x0,0x0,0x209,0x209,0x0,0x23b,0x100,0x100,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x23b,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x1000,0x20,0x0,0x0,0x0,0x10,0x800,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000,0x0,0x110000,0x0,0x110000,0x0,0x0,0x1000,0x0,0x0,0x0,0x110000,0x0,0x0,0x1000,0x111000,0x0,0x0,0x0,0x0,0x1000,0x0,0x110000,0x0,0x0,0x110000,0x0,0x8000,0x0,0x0,0x8000,0x0,0x20000024,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x23b,0x0,0x200000,0x1000,0x0,0x0,0x0,0x20,0xc0000000,0xc0000000,0x0,0x1000000,0x0,0x800000,0x0,0x800000,0x0,0x400,0x0,0x0,0x0,0x0,0x10000,0x0,0x110000,0x0,0x110000,0x0,0x0,0x110000,0x10000,0x0,0x100000,0x100000,0x0,0x110000,0x20000024,0x0,0x0,0x0,0x0,0x600000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x23b,0x0,0x0,0x110000,0x0,0x0,0x110000,0x0,0x110000,0x110000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x110000,0x28000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x800,0x23b,0x0,0x0,0x0,0x0,0x1000000,0x0,0x800,0x0,0x0,0x0,0x800,0x0,0x0,0x110000,0x100000,0x100000,0x0,0x0,0x2000,0x0,0x138000,};
12   unsigned int jj_la1_3[] = {
13 0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x188830,0x8000000,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x80000,0x0,0x108830,0x80000,0x0,0x188830,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x2000000,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x2000000,0x0,0x0,0x80000,0x80000,0x0,0x0,0x80000,0x0,0x0,0x4000,0x80000,0x80000,0x0,0x2000,0x0,0x0,0x128810,0x0,0x0,0x0,0x0,0x0,0x108830,0x80000,0x0,0x0,0x188830,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x30000000,0x30000000,0x0,0x30000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x30000000,0x0,0x0,0x0,0x0,0x108030,0x0,0x100030,0x100030,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x108030,0x0,0x4000,0x0,0x0,0x188820,0x0,0x188820,0x0,0x0,0x0,0x0,0x0,0x0,0x108830,0x80000,0x0,0x0,0x188830,0x0,0x0,0x0,0x0,0x0,0x0,0x108820,0x80000,0x0,0x188820,0x0,0x0,0x0,0x0,0x0,0x0,0xd000001,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x30000000,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x3c0,0x3c0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x108820,0x80000,0x0,0x188820,0x0,0x0,0x0,0x0,0x0,0x0,0xd000001,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x8000000,0x20,0x0,0x0,0x0,0x40000,0x0,0x0,0x30010000,0x0,0x0,0x108820,0x80000,0x0,0x188820,0x0,0x80000,0x80000,0x0,0x80000,0x0,0x0,0x80000,0x0,0x0,0x0,0x2000000,0x0,0x188830,0x8000000,0x0,0x0,0x100010,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x2000000,0x0,0x30000000,0x8000000,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
14   unsigned int jj_la1_4[] = {
15 0x0,0x0,0x0,0x20000,0x30,0x40,0x100,0x0,0x0,0x0,0x0,0x40000,0x0,0x40001,0x0,0x0,0x0,0x0,0x40,0x0,0x40000,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x40001,0x8000000,0x0,0x0,0x0,0x0,0x10000000,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x20000,0x40,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40000,0x40000,0x40000,0x40000,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x4,0x140001,0x0,0x0,0x0,0x40000,0x1,0x0,0x0,0x40000,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x140031,0x0,0x1,0x0,0x40000,0x0,0x200,0x0,0x0,0x0,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x40000008,0x40000,0x40,0x1,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x1,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x40001,0x1,0x40000,0x40000,0x7e0fc00,0x7e0fc00,0x0,0x0,0x0,0x140031,0x0,0x0,0x0,0x40,0x40,0x40000,0x0,0x0,0x0,0x30,0x0,0x40001,0x0,0x80,0x0,0x40,0x40000,0x40,0x40000,0x0,0x30,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1,0x0,0x40001,0x40000,0x0,0x40001,0x0,0x1,0x0,0x40,0x40,0x40001,0x0,0x80,0x0,0x0,0x0,0x0,0x40,0x140031,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40001,0x0,0x0,0x0,0xa0000000,0x20000000,0x0,0x1,0x40001,0x0,0x0,0x0,0x0,0x140031,0x0,0x8000000,0x40000,0x8000000,0x0,0x8000000,0x0,0x240,0x240,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x1,0x0,};
16   unsigned int jj_la1_5[] = {
17 0x1420,0x0,0x180,0x0,0x0,0x0,0x0,0x2,0x3c0,0x0,0x0,0x1c0,0x0,0x200001c0,0x0,0x0,0x0,0x180,0x0,0x180,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x200001c0,0x0,0x180,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x20000000,0x20000000,0x2,0x0,0x0,0x0,0x3c0,0x1c0,0x1c0,0x3c0,0x380,0x0,0x180,0x180,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x0,0x0,0x1e0,0x0,0x180,0x0,0x3c0,0x0,0x180,0x0,0x180,0x0,0x0,0x180,0x0,0x1017e0,0x0,0x0,0x180,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x180,0x0,0x180,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x180,0x180,0x0,0x180,0x1420,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x1c0,0x0,0x1c0,0x1c0,0x0,0x0,0x180,0x0,0x180,0x1017e0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x180,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x1c0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x1c0,0x240,0x1c0,0x0,0x0,0x0,0x0,0x0,0x1c0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x180,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x200001c0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x1c0,0x0,0x0,0x0,0x0,0x1017e0,0x0,0x0,0x1c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180,0x0,0x0,0x0,0x180,};
18 
19   /** Constructor with user supplied TokenManager. */
20 
21 
22 
23 
abstract_literal()24 QCString VhdlParser::abstract_literal() {Token *tok;
25     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
26     case DECIMAL_LITERAL:{
27       if (!hasError) {
28       tok = jj_consume_token(DECIMAL_LITERAL);
29       }
30       if (!hasError) {
31 return QCString(tok->image);
32       }
33       break;
34       }
35     case INTEGER:{
36       if (!hasError) {
37       tok = jj_consume_token(INTEGER);
38       }
39       if (!hasError) {
40 return QCString(tok->image);
41       }
42       break;
43       }
44     case BASED_LITERAL:{
45       if (!hasError) {
46       tok = jj_consume_token(BASED_LITERAL);
47       }
48       if (!hasError) {
49 return QCString(tok->image);
50       }
51       break;
52       }
53     default:
54       jj_la1[0] = jj_gen;
55       jj_consume_token(-1);
56       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
57     }
58 assert(false);
59 }
60 
61 
access_type_definition()62 QCString VhdlParser::access_type_definition() {Token *tok=0;QCString str,str1;
63     if (!hasError) {
64     tok = jj_consume_token(ACCESS_T);
65     }
66     if (!hasError) {
67     str1 = subtype_indication();
68     }
69 str=tok->image; return str+str1;
70 assert(false);
71 }
72 
73 
actual_designator()74 QCString VhdlParser::actual_designator() {QCString str;Token *t=0;
75     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
76     case OPEN_T:{
77       if (!hasError) {
78       t = jj_consume_token(OPEN_T);
79       }
80       if (!hasError) {
81 return QCString(t->image);
82       }
83       break;
84       }
85     default:
86       jj_la1[1] = jj_gen;
87       if (jj_2_1(2147483647)) {
88         if (!hasError) {
89         str = expression();
90         }
91         if (!hasError) {
92 return str;
93         }
94       } else {
95         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
96         case BASIC_IDENTIFIER:
97         case EXTENDED_CHARACTER:{
98           if (!hasError) {
99           str = identifier();
100           }
101           if (!hasError) {
102 return str;
103           }
104           break;
105           }
106         default:
107           jj_la1[2] = jj_gen;
108           jj_consume_token(-1);
109           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
110         }
111       }
112     }
113 assert(false);
114 }
115 
116 
actual_parameter_part()117 QCString VhdlParser::actual_parameter_part() {QCString s;
118     if (!hasError) {
119     s = association_list();
120     }
121 return s;
122 assert(false);
123 }
124 
125 
actual_part()126 QCString VhdlParser::actual_part() {QCString s,s1;
127     if (jj_2_2(2147483647)) {
128       if (!hasError) {
129       s = actual_designator();
130       }
131       if (!hasError) {
132 return s;
133       }
134     } else {
135       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
136       case BOX_T:{
137         if (!hasError) {
138         jj_consume_token(BOX_T);
139         }
140         if (!hasError) {
141 return "<>";
142         }
143         break;
144         }
145       default:
146         jj_la1[3] = jj_gen;
147         if (jj_2_3(2147483647)) {
148           if (!hasError) {
149           s = name();
150           }
151           if (!hasError) {
152           jj_consume_token(LPAREN_T);
153           }
154           if (!hasError) {
155           s1 = actual_designator();
156           }
157           if (!hasError) {
158           jj_consume_token(RPAREN_T);
159           }
160           if (!hasError) {
161 s+="(";s+=s1+")";return s;
162           }
163         } else {
164           jj_consume_token(-1);
165           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
166         }
167       }
168     }
169 assert(false);
170 }
171 
172 
adding_operator()173 QCString VhdlParser::adding_operator() {
174     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
175     case PLUS_T:{
176       if (!hasError) {
177       jj_consume_token(PLUS_T);
178       }
179       if (!hasError) {
180 return "+";
181       }
182       break;
183       }
184     case MINUS_T:{
185       if (!hasError) {
186       jj_consume_token(MINUS_T);
187       }
188       if (!hasError) {
189 return "-";
190       }
191       break;
192       }
193     case AMPERSAND_T:{
194       if (!hasError) {
195       jj_consume_token(AMPERSAND_T);
196       }
197       if (!hasError) {
198 return "&";
199       }
200       break;
201       }
202     default:
203       jj_la1[4] = jj_gen;
204       jj_consume_token(-1);
205       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
206     }
207 assert(false);
208 }
209 
210 
aggregate()211 QCString VhdlParser::aggregate() {QCString s,s1,s2;
212     if (!hasError) {
213     jj_consume_token(LPAREN_T);
214     }
215     if (!hasError) {
216     s = element_association();
217     }
218     if (!hasError) {
219     while (!hasError) {
220       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
221       case COMMA_T:{
222         ;
223         break;
224         }
225       default:
226         jj_la1[5] = jj_gen;
227         goto end_label_1;
228       }
229       if (!hasError) {
230       jj_consume_token(COMMA_T);
231       }
232       if (!hasError) {
233       s1 = element_association();
234       }
235       if (!hasError) {
236 s+=","+s1;
237       }
238     }
239     end_label_1: ;
240     }
241     if (!hasError) {
242     jj_consume_token(RPAREN_T);
243     }
244 return QCString("("+s+")");
245 assert(false);
246 }
247 
248 
alias_declaration()249 QCString VhdlParser::alias_declaration() {QCString s,s1,s2;
250     if (!hasError) {
251     jj_consume_token(ALIAS_T);
252     }
253     if (!hasError) {
254     s2 = alias_designator();
255     }
256     if (!hasError) {
257     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
258     case COLON_T:{
259       if (!hasError) {
260       jj_consume_token(COLON_T);
261       }
262       if (!hasError) {
263 s+=":";
264       }
265       if (!hasError) {
266       s1 = subtype_indication();
267       }
268       if (!hasError) {
269 s+=s1;
270       }
271       break;
272       }
273     default:
274       jj_la1[6] = jj_gen;
275       ;
276     }
277     }
278     if (!hasError) {
279     jj_consume_token(IS_T);
280     }
281     if (!hasError) {
282 s+=" is ";
283     }
284     if (!hasError) {
285     s1 = name();
286     }
287     if (!hasError) {
288 s+=s1;
289     }
290     if (!hasError) {
291     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
292     case LBRACKET_T:{
293       if (!hasError) {
294       s1 = signature();
295       }
296       if (!hasError) {
297 s+=s1;
298       }
299       break;
300       }
301     default:
302       jj_la1[7] = jj_gen;
303       ;
304     }
305     }
306     if (!hasError) {
307     jj_consume_token(SEMI_T);
308     }
309 outlineParser()->addVhdlType(s2.data(),outlineParser()->getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
310 
311  return s2+" "+s+";";
312 assert(false);
313 }
314 
315 
alias_designator()316 QCString VhdlParser::alias_designator() {Token *tok=0;QCString s;
317     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
318     case BASIC_IDENTIFIER:
319     case EXTENDED_CHARACTER:{
320       if (!hasError) {
321       s = identifier();
322       }
323       if (!hasError) {
324 return s;
325       }
326       break;
327       }
328     case CHARACTER_LITERAL:{
329       if (!hasError) {
330       tok = jj_consume_token(CHARACTER_LITERAL);
331       }
332       if (!hasError) {
333 return QCString(tok->image);
334       }
335       break;
336       }
337     case STRINGLITERAL:{
338       if (!hasError) {
339       s = operator_symbol();
340       }
341       if (!hasError) {
342 return s;
343       }
344       break;
345       }
346     default:
347       jj_la1[8] = jj_gen;
348       jj_consume_token(-1);
349       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
350     }
351 assert(false);
352 }
353 
354 
allocator()355 void VhdlParser::allocator() {
356     if (jj_2_4(3)) {
357       if (!hasError) {
358       jj_consume_token(NEW_T);
359       }
360       if (!hasError) {
361       qualified_expression();
362       }
363     } else {
364       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
365       case NEW_T:{
366         if (!hasError) {
367         jj_consume_token(NEW_T);
368         }
369         if (!hasError) {
370         subtype_indication();
371         }
372         break;
373         }
374       default:
375         jj_la1[9] = jj_gen;
376         jj_consume_token(-1);
377         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
378       }
379     }
380 }
381 
382 
architecture_body()383 void VhdlParser::architecture_body() {QCString s,s1;
384     if (!hasError) {
385     jj_consume_token(ARCHITECTURE_T);
386     }
387     if (!hasError) {
388     s = identifier();
389     }
390     if (!hasError) {
391     jj_consume_token(OF_T);
392     }
393     if (!hasError) {
394     s1 = name();
395     }
396     if (!hasError) {
397     jj_consume_token(IS_T);
398     }
399     if (!hasError) {
400 QCString t=s1+"::"+s;
401     m_sharedState->genLabels.resize(0);
402     outlineParser()->pushLabel(m_sharedState->genLabels,s1);
403     m_sharedState->lastCompound=m_sharedState->current;
404     outlineParser()->addVhdlType(t.data(),outlineParser()->getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
405     }
406     if (!hasError) {
407     try {
408       if (!hasError) {
409       architecture_declarative_part();
410       }
411     } catch ( ...) {
412 outlineParser()->error_skipto(BEGIN_T);
413     }
414     }
415     if (!hasError) {
416     jj_consume_token(BEGIN_T);
417     }
418     if (!hasError) {
419     architecture_statement_part();
420     }
421     if (!hasError) {
422     jj_consume_token(END_T);
423     }
424     if (!hasError) {
425     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
426     case ARCHITECTURE_T:{
427       if (!hasError) {
428       jj_consume_token(ARCHITECTURE_T);
429       }
430       break;
431       }
432     default:
433       jj_la1[10] = jj_gen;
434       ;
435     }
436     }
437     if (!hasError) {
438     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
439     case SLSL_T:
440     case STRINGLITERAL:
441     case BASIC_IDENTIFIER:
442     case EXTENDED_CHARACTER:{
443       if (!hasError) {
444       name();
445       }
446       break;
447       }
448     default:
449       jj_la1[11] = jj_gen;
450       ;
451     }
452     }
453     if (!hasError) {
454     jj_consume_token(SEMI_T);
455     }
456 m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
457 }
458 
459 
architecture_declarative_part()460 void VhdlParser::architecture_declarative_part() {
461     if (!hasError) {
462     while (!hasError) {
463       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
464       case ALIAS_T:
465       case ATTRIBUTE_T:
466       case COMPONENT_T:
467       case CONSTANT_T:
468       case DISCONNECT_T:
469       case FILE_T:
470       case FOR_T:
471       case FUNCTION_T:
472       case GROUP_T:
473       case IMPURE_T:
474       case PROCEDURE_T:
475       case PURE_T:
476       case SIGNAL_T:
477       case SHARED_T:
478       case SUBTYPE_T:
479       case TYPE_T:
480       case USE_T:
481       case VARIABLE_T:{
482         ;
483         break;
484         }
485       default:
486         jj_la1[12] = jj_gen;
487         goto end_label_2;
488       }
489       if (!hasError) {
490       block_declarative_item();
491       }
492     }
493     end_label_2: ;
494     }
495 }
496 
497 
architecture_statement_part()498 void VhdlParser::architecture_statement_part() {
499     if (!hasError) {
500     while (!hasError) {
501       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
502       case ASSERT_T:
503       case CASE_T:
504       case POSTPONED_T:
505       case PROCESS_T:
506       case WITH_T:
507       case LPAREN_T:
508       case SLSL_T:
509       case STRINGLITERAL:
510       case BASIC_IDENTIFIER:
511       case EXTENDED_CHARACTER:
512       case VHDL2008TOOLDIR:{
513         ;
514         break;
515         }
516       default:
517         jj_la1[13] = jj_gen;
518         goto end_label_3;
519       }
520       if (!hasError) {
521       concurrent_statement();
522       }
523     }
524     end_label_3: ;
525     }
526 }
527 
528 
array_type_definition()529 QCString VhdlParser::array_type_definition() {QCString s;
530     if (jj_2_5(2147483647)) {
531       if (!hasError) {
532       s = constraint_array_definition();
533       }
534       if (!hasError) {
535 return s;
536       }
537     } else {
538       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
539       case ARRAY_T:{
540         if (!hasError) {
541         s = unconstraint_array_definition();
542         }
543         if (!hasError) {
544 return s;
545         }
546         break;
547         }
548       default:
549         jj_la1[14] = jj_gen;
550         jj_consume_token(-1);
551         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
552       }
553     }
554 assert(false);
555 }
556 
557 
assertion()558 QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;
559     if (!hasError) {
560     jj_consume_token(ASSERT_T);
561     }
562     if (!hasError) {
563     s = condition();
564     }
565     if (!hasError) {
566     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
567     case REPORT_T:{
568       if (!hasError) {
569       t = jj_consume_token(REPORT_T);
570       }
571       if (!hasError) {
572       s1 = expression();
573       }
574       break;
575       }
576     default:
577       jj_la1[15] = jj_gen;
578       ;
579     }
580     }
581     if (!hasError) {
582     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
583     case SEVERITY_T:{
584       if (!hasError) {
585       t1 = jj_consume_token(SEVERITY_T);
586       }
587       if (!hasError) {
588       s2 = expression();
589       }
590       break;
591       }
592     default:
593       jj_la1[16] = jj_gen;
594       ;
595     }
596     }
597 s.prepend("assert ");
598    if(t) s1.prepend(" report ");
599    if(t1) s2.prepend(" report ");
600     return s+s1+s2;
601 assert(false);
602 }
603 
604 
assertion_statement()605 QCString VhdlParser::assertion_statement() {QCString s,s1,s2;Token *t=0;
606     if (!hasError) {
607     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
608     case BASIC_IDENTIFIER:
609     case EXTENDED_CHARACTER:{
610       if (!hasError) {
611       s = label();
612       }
613       if (!hasError) {
614       t = jj_consume_token(COLON_T);
615       }
616       break;
617       }
618     default:
619       jj_la1[17] = jj_gen;
620       ;
621     }
622     }
623     if (!hasError) {
624     s1 = assertion();
625     }
626     if (!hasError) {
627     jj_consume_token(SEMI_T);
628     }
629 if(t) s+=":";
630     return s+s1+";";
631 assert(false);
632 }
633 
634 
association_element()635 QCString VhdlParser::association_element() {QCString s,s1;
636     if (!hasError) {
637     if (jj_2_6(2147483647)) {
638       if (!hasError) {
639       s = formal_part();
640       }
641       if (!hasError) {
642       jj_consume_token(ARROW_T);
643       }
644     } else {
645       ;
646     }
647     }
648     if (!hasError) {
649     s1 = actual_part();
650     }
651 return s+" => "+s1;
652 assert(false);
653 }
654 
655 
association_list()656 QCString VhdlParser::association_list() {QCString s,s1;
657     if (!hasError) {
658     s = association_element();
659     }
660     if (!hasError) {
661     while (!hasError) {
662       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
663       case COMMA_T:{
664         ;
665         break;
666         }
667       default:
668         jj_la1[18] = jj_gen;
669         goto end_label_4;
670       }
671       if (!hasError) {
672       jj_consume_token(COMMA_T);
673       }
674       if (!hasError) {
675       s1 = association_element();
676       }
677       if (!hasError) {
678 s+=","+s1;
679       }
680     }
681     end_label_4: ;
682     }
683 return s;
684 assert(false);
685 }
686 
687 
attribute_declaration()688 QCString VhdlParser::attribute_declaration() {QCString s,s1;
689     if (!hasError) {
690     jj_consume_token(ATTRIBUTE_T);
691     }
692     if (!hasError) {
693     s = identifier();
694     }
695     if (!hasError) {
696     jj_consume_token(COLON_T);
697     }
698     if (!hasError) {
699     s1 = type_mark();
700     }
701     if (!hasError) {
702     jj_consume_token(SEMI_T);
703     }
704 outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
705     return " attribute "+s+":"+s1+";";
706 assert(false);
707 }
708 
709 
attribute_designator()710 QCString VhdlParser::attribute_designator() {QCString s;Token *tok=0;
711     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
712     case BASIC_IDENTIFIER:
713     case EXTENDED_CHARACTER:{
714       if (!hasError) {
715       s = identifier();
716       }
717       if (!hasError) {
718 return s;
719       }
720       break;
721       }
722     case RANGE_T:{
723       if (!hasError) {
724       tok = jj_consume_token(RANGE_T);
725       }
726       if (!hasError) {
727 return QCString(tok->image);
728       }
729       break;
730       }
731     default:
732       jj_la1[19] = jj_gen;
733       jj_consume_token(-1);
734       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
735     }
736 assert(false);
737 }
738 
739 
attribute_name()740 QCString VhdlParser::attribute_name() {QCString s,s1;
741     if (!hasError) {
742     s = identifier();
743     }
744     if (!hasError) {
745     jj_consume_token(APOSTROPHE_T);
746     }
747     if (!hasError) {
748     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
749     case RANGE_T:{
750       if (!hasError) {
751       jj_consume_token(RANGE_T);
752       }
753       break;
754       }
755     case SLSL_T:
756     case STRINGLITERAL:
757     case BASIC_IDENTIFIER:
758     case EXTENDED_CHARACTER:{
759       if (!hasError) {
760       s1 = name();
761       }
762       break;
763       }
764     default:
765       jj_la1[20] = jj_gen;
766       jj_consume_token(-1);
767       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
768     }
769     }
770     if (!hasError) {
771 s+=s1;
772     }
773     if (!hasError) {
774     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
775     case LPAREN_T:{
776       if (!hasError) {
777       jj_consume_token(LPAREN_T);
778       }
779       if (!hasError) {
780       s1 = expression();
781       }
782       if (!hasError) {
783       jj_consume_token(RPAREN_T);
784       }
785       if (!hasError) {
786 s+=s1;
787       }
788       break;
789       }
790     default:
791       jj_la1[21] = jj_gen;
792       ;
793     }
794     }
795 return s;
796 assert(false);
797 }
798 
799 
attribute_specification()800 QCString VhdlParser::attribute_specification() {QCString s,s1,s2;
801     if (!hasError) {
802     jj_consume_token(ATTRIBUTE_T);
803     }
804     if (!hasError) {
805     s = attribute_designator();
806     }
807     if (!hasError) {
808     jj_consume_token(OF_T);
809     }
810     if (!hasError) {
811     s1 = entity_specification();
812     }
813     if (!hasError) {
814     jj_consume_token(IS_T);
815     }
816     if (!hasError) {
817     s2 = expression();
818     }
819     if (!hasError) {
820     jj_consume_token(SEMI_T);
821     }
822 QCString t= s1+" is "+s2;
823    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
824    return " attribute "+s+" of "+s1+ " is "+s2+";";
825 assert(false);
826 }
827 
828 
base()829 QCString VhdlParser::base() {Token *tok=0;
830     if (!hasError) {
831     tok = jj_consume_token(INTEGER);
832     }
833 return QCString(tok->image);
834 assert(false);
835 }
836 
837 
base_specifier()838 QCString VhdlParser::base_specifier() {Token *tok=0;
839     if (!hasError) {
840     tok = jj_consume_token(BASIC_IDENTIFIER);
841     }
842 return QCString(tok->image);
843 assert(false);
844 }
845 
846 
base_unit_declaration()847 QCString VhdlParser::base_unit_declaration() {QCString s;
848     if (!hasError) {
849     s = identifier();
850     }
851 return s;
852 assert(false);
853 }
854 
855 
based_integer()856 QCString VhdlParser::based_integer() {Token *tok=0;
857     if (!hasError) {
858     tok = jj_consume_token(BASIC_IDENTIFIER);
859     }
860 return QCString(tok->image);
861 assert(false);
862 }
863 
864 
based_literal()865 QCString VhdlParser::based_literal() {Token *tok=0;
866     if (!hasError) {
867     tok = jj_consume_token(BASED_LITERAL);
868     }
869 return QCString(tok->image);
870 assert(false);
871 }
872 
873 
basic_identifier()874 QCString VhdlParser::basic_identifier() {Token *tok=0;
875     if (!hasError) {
876     tok = jj_consume_token(BASIC_IDENTIFIER);
877     }
878 return QCString(tok->image);
879 assert(false);
880 }
881 
882 
binding_indication()883 void VhdlParser::binding_indication() {
884     if (!hasError) {
885     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
886     case USE_T:{
887       if (!hasError) {
888       jj_consume_token(USE_T);
889       }
890       if (!hasError) {
891       entity_aspect();
892       }
893       break;
894       }
895     default:
896       jj_la1[22] = jj_gen;
897       ;
898     }
899     }
900     if (!hasError) {
901     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
902     case GENERIC_T:{
903       if (!hasError) {
904       generic_map_aspect();
905       }
906       break;
907       }
908     default:
909       jj_la1[23] = jj_gen;
910       ;
911     }
912     }
913     if (!hasError) {
914     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
915     case PORT_T:{
916       if (!hasError) {
917       port_map_aspect();
918       }
919       break;
920       }
921     default:
922       jj_la1[24] = jj_gen;
923       ;
924     }
925     }
926 }
927 
928 
bit_string_literal()929 QCString VhdlParser::bit_string_literal() {Token *tok=0;
930     if (!hasError) {
931     tok = jj_consume_token(BIT_STRING_LITERAL);
932     }
933 return QCString(tok->image);
934 assert(false);
935 }
936 
937 
bit_value()938 QCString VhdlParser::bit_value() {Token *tok=0;
939     if (!hasError) {
940     tok = jj_consume_token(BASIC_IDENTIFIER);
941     }
942 return QCString(tok->image);
943 assert(false);
944 }
945 
946 
block_configuration()947 void VhdlParser::block_configuration() {
948     if (!hasError) {
949     jj_consume_token(FOR_T);
950     }
951     if (!hasError) {
952     block_specification();
953     }
954     if (!hasError) {
955     while (!hasError) {
956       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
957       case USE_T:{
958         ;
959         break;
960         }
961       default:
962         jj_la1[25] = jj_gen;
963         goto end_label_5;
964       }
965       if (!hasError) {
966       use_clause();
967       }
968     }
969     end_label_5: ;
970     }
971     if (!hasError) {
972     while (!hasError) {
973       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
974       case FOR_T:{
975         ;
976         break;
977         }
978       default:
979         jj_la1[26] = jj_gen;
980         goto end_label_6;
981       }
982       if (!hasError) {
983       configuration_item();
984       }
985     }
986     end_label_6: ;
987     }
988     if (!hasError) {
989     jj_consume_token(END_T);
990     }
991     if (!hasError) {
992     jj_consume_token(FOR_T);
993     }
994     if (!hasError) {
995     jj_consume_token(SEMI_T);
996     }
997 }
998 
999 
block_declarative_item()1000 void VhdlParser::block_declarative_item() {
1001     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1002     case FUNCTION_T:
1003     case IMPURE_T:
1004     case PROCEDURE_T:
1005     case PURE_T:{
1006       if (!hasError) {
1007       subprogram_declaration();
1008       }
1009       break;
1010       }
1011     case TYPE_T:{
1012       if (!hasError) {
1013       type_declaration();
1014       }
1015       break;
1016       }
1017     case SUBTYPE_T:{
1018       if (!hasError) {
1019       subtype_declaration();
1020       }
1021       break;
1022       }
1023     case CONSTANT_T:{
1024       if (!hasError) {
1025       constant_declaration();
1026       }
1027       break;
1028       }
1029     case SIGNAL_T:{
1030       if (!hasError) {
1031       signal_declaration();
1032       }
1033       break;
1034       }
1035     case SHARED_T:
1036     case VARIABLE_T:{
1037       if (!hasError) {
1038       variable_declaration();
1039       }
1040       break;
1041       }
1042     case FILE_T:{
1043       if (!hasError) {
1044       file_declaration();
1045       }
1046       break;
1047       }
1048     case ALIAS_T:{
1049       if (!hasError) {
1050       alias_declaration();
1051       }
1052       break;
1053       }
1054     case COMPONENT_T:{
1055       if (!hasError) {
1056       component_declaration();
1057       }
1058       break;
1059       }
1060     default:
1061       jj_la1[27] = jj_gen;
1062       if (jj_2_7(2147483647)) {
1063         if (!hasError) {
1064         attribute_declaration();
1065         }
1066       } else {
1067         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1068         case ATTRIBUTE_T:{
1069           if (!hasError) {
1070           attribute_specification();
1071           }
1072           break;
1073           }
1074         case FOR_T:{
1075           if (!hasError) {
1076           configuration_specification();
1077           }
1078           break;
1079           }
1080         case DISCONNECT_T:{
1081           if (!hasError) {
1082           disconnection_specification();
1083           }
1084           break;
1085           }
1086         case USE_T:{
1087           if (!hasError) {
1088           use_clause();
1089           }
1090           break;
1091           }
1092         default:
1093           jj_la1[28] = jj_gen;
1094           if (jj_2_8(3)) {
1095             if (!hasError) {
1096             group_template_declaration();
1097             }
1098           } else {
1099             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1100             case GROUP_T:{
1101               if (!hasError) {
1102               group_declaration();
1103               }
1104               break;
1105               }
1106             default:
1107               jj_la1[29] = jj_gen;
1108               jj_consume_token(-1);
1109               errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1110             }
1111           }
1112         }
1113       }
1114     }
1115 }
1116 
1117 
block_declarative_part()1118 void VhdlParser::block_declarative_part() {
1119     if (!hasError) {
1120     while (!hasError) {
1121       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1122       case ALIAS_T:
1123       case ATTRIBUTE_T:
1124       case COMPONENT_T:
1125       case CONSTANT_T:
1126       case DISCONNECT_T:
1127       case FILE_T:
1128       case FOR_T:
1129       case FUNCTION_T:
1130       case GROUP_T:
1131       case IMPURE_T:
1132       case PROCEDURE_T:
1133       case PURE_T:
1134       case SIGNAL_T:
1135       case SHARED_T:
1136       case SUBTYPE_T:
1137       case TYPE_T:
1138       case USE_T:
1139       case VARIABLE_T:{
1140         ;
1141         break;
1142         }
1143       default:
1144         jj_la1[30] = jj_gen;
1145         goto end_label_7;
1146       }
1147       if (!hasError) {
1148       block_declarative_item();
1149       }
1150     }
1151     end_label_7: ;
1152     }
1153 }
1154 
1155 
block_header()1156 void VhdlParser::block_header() {
1157     if (!hasError) {
1158     if (jj_2_9(2147483647)) {
1159       if (!hasError) {
1160       generic_clause();
1161       }
1162       if (!hasError) {
1163       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1164       case GENERIC_T:{
1165         if (!hasError) {
1166         generic_map_aspect();
1167         }
1168         if (!hasError) {
1169         jj_consume_token(SEMI_T);
1170         }
1171         break;
1172         }
1173       default:
1174         jj_la1[31] = jj_gen;
1175         ;
1176       }
1177       }
1178     } else {
1179       ;
1180     }
1181     }
1182     if (!hasError) {
1183     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1184     case PORT_T:{
1185       if (!hasError) {
1186       port_clause();
1187       }
1188       if (!hasError) {
1189       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1190       case PORT_T:{
1191         if (!hasError) {
1192         port_map_aspect();
1193         }
1194         if (!hasError) {
1195         jj_consume_token(SEMI_T);
1196         }
1197         break;
1198         }
1199       default:
1200         jj_la1[32] = jj_gen;
1201         ;
1202       }
1203       }
1204       break;
1205       }
1206     default:
1207       jj_la1[33] = jj_gen;
1208       ;
1209     }
1210     }
1211 }
1212 
1213 
block_specification()1214 void VhdlParser::block_specification() {
1215     if (!hasError) {
1216     name();
1217     }
1218     if (!hasError) {
1219     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1220     case LPAREN_T:{
1221       if (!hasError) {
1222       jj_consume_token(LPAREN_T);
1223       }
1224       if (!hasError) {
1225       index_specification();
1226       }
1227       if (!hasError) {
1228       jj_consume_token(RPAREN_T);
1229       }
1230       break;
1231       }
1232     default:
1233       jj_la1[34] = jj_gen;
1234       ;
1235     }
1236     }
1237 }
1238 
1239 
block_statement()1240 void VhdlParser::block_statement() {QCString s;
1241     if (!hasError) {
1242     s = identifier();
1243     }
1244     if (!hasError) {
1245     jj_consume_token(COLON_T);
1246     }
1247     if (!hasError) {
1248     jj_consume_token(BLOCK_T);
1249     }
1250     if (!hasError) {
1251 outlineParser()->pushLabel(m_sharedState->genLabels,s);
1252     }
1253     if (!hasError) {
1254     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1255     case LPAREN_T:{
1256       if (!hasError) {
1257       jj_consume_token(LPAREN_T);
1258       }
1259       if (!hasError) {
1260       expression();
1261       }
1262       if (!hasError) {
1263       jj_consume_token(RPAREN_T);
1264       }
1265       break;
1266       }
1267     default:
1268       jj_la1[35] = jj_gen;
1269       ;
1270     }
1271     }
1272     if (!hasError) {
1273     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1274     case IS_T:{
1275       if (!hasError) {
1276       jj_consume_token(IS_T);
1277       }
1278       break;
1279       }
1280     default:
1281       jj_la1[36] = jj_gen;
1282       ;
1283     }
1284     }
1285     if (!hasError) {
1286     block_header();
1287     }
1288     if (!hasError) {
1289     block_declarative_part();
1290     }
1291     if (!hasError) {
1292     jj_consume_token(BEGIN_T);
1293     }
1294     if (!hasError) {
1295     block_statement_part();
1296     }
1297     if (!hasError) {
1298     jj_consume_token(END_T);
1299     }
1300     if (!hasError) {
1301     jj_consume_token(BLOCK_T);
1302     }
1303     if (!hasError) {
1304     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1305     case BASIC_IDENTIFIER:
1306     case EXTENDED_CHARACTER:{
1307       if (!hasError) {
1308       identifier();
1309       }
1310       break;
1311       }
1312     default:
1313       jj_la1[37] = jj_gen;
1314       ;
1315     }
1316     }
1317     if (!hasError) {
1318     jj_consume_token(SEMI_T);
1319     }
1320 m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels);
1321 }
1322 
1323 
block_statement_part()1324 void VhdlParser::block_statement_part() {
1325     if (!hasError) {
1326     while (!hasError) {
1327       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1328       case ASSERT_T:
1329       case CASE_T:
1330       case POSTPONED_T:
1331       case PROCESS_T:
1332       case WITH_T:
1333       case LPAREN_T:
1334       case SLSL_T:
1335       case STRINGLITERAL:
1336       case BASIC_IDENTIFIER:
1337       case EXTENDED_CHARACTER:
1338       case VHDL2008TOOLDIR:{
1339         ;
1340         break;
1341         }
1342       default:
1343         jj_la1[38] = jj_gen;
1344         goto end_label_8;
1345       }
1346       if (!hasError) {
1347       concurrent_statement();
1348       }
1349     }
1350     end_label_8: ;
1351     }
1352 }
1353 
1354 
case_statement()1355 void VhdlParser::case_statement() {QCString s;
1356     if (!hasError) {
1357     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1358     case BASIC_IDENTIFIER:
1359     case EXTENDED_CHARACTER:{
1360       if (!hasError) {
1361       identifier();
1362       }
1363       if (!hasError) {
1364       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1365       case Q_T:{
1366         if (!hasError) {
1367         jj_consume_token(Q_T);
1368         }
1369         break;
1370         }
1371       default:
1372         jj_la1[39] = jj_gen;
1373         ;
1374       }
1375       }
1376       if (!hasError) {
1377       jj_consume_token(COLON_T);
1378       }
1379       break;
1380       }
1381     default:
1382       jj_la1[40] = jj_gen;
1383       ;
1384     }
1385     }
1386     if (!hasError) {
1387     jj_consume_token(CASE_T);
1388     }
1389     if (!hasError) {
1390     s = expression();
1391     }
1392     if (!hasError) {
1393 QCString ca="case "+s;
1394      FlowChart::addFlowChart(FlowChart::CASE_NO,QCString(),ca);
1395     }
1396     if (!hasError) {
1397     jj_consume_token(IS_T);
1398     }
1399     if (!hasError) {
1400     case_statement_alternative();
1401     }
1402     if (!hasError) {
1403     while (!hasError) {
1404       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1405       case WHEN_T:{
1406         ;
1407         break;
1408         }
1409       default:
1410         jj_la1[41] = jj_gen;
1411         goto end_label_9;
1412       }
1413       if (!hasError) {
1414       case_statement_alternative();
1415       }
1416     }
1417     end_label_9: ;
1418     }
1419     if (!hasError) {
1420     jj_consume_token(END_T);
1421     }
1422     if (!hasError) {
1423     jj_consume_token(CASE_T);
1424     }
1425     if (!hasError) {
1426     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1427     case BASIC_IDENTIFIER:
1428     case EXTENDED_CHARACTER:{
1429       if (!hasError) {
1430       identifier();
1431       }
1432       break;
1433       }
1434     default:
1435       jj_la1[42] = jj_gen;
1436       ;
1437     }
1438     }
1439     if (!hasError) {
1440     jj_consume_token(SEMI_T);
1441     }
1442 FlowChart::moveToPrevLevel();
1443          FlowChart::addFlowChart(FlowChart::END_CASE,"end case",QCString());
1444 }
1445 
1446 
case_statement_alternative()1447 void VhdlParser::case_statement_alternative() {QCString s;
1448     if (!hasError) {
1449     jj_consume_token(WHEN_T);
1450     }
1451     if (!hasError) {
1452     s = choices();
1453     }
1454     if (!hasError) {
1455     jj_consume_token(ARROW_T);
1456     }
1457     if (!hasError) {
1458 QCString t("when ");
1459     t+=s+"=> ";
1460     FlowChart::addFlowChart(FlowChart::WHEN_NO,s,t);
1461     }
1462     if (!hasError) {
1463     sequence_of_statement();
1464     }
1465 FlowChart::moveToPrevLevel();
1466 }
1467 
1468 
character_literal()1469 QCString VhdlParser::character_literal() {Token *tok=0;
1470     if (!hasError) {
1471     tok = jj_consume_token(CHARACTER_LITERAL);
1472     }
1473 return QCString(tok->image);
1474 assert(false);
1475 }
1476 
1477 
choice()1478 QCString VhdlParser::choice() {QCString s;
1479     if (jj_2_10(2147483647)) {
1480       if (!hasError) {
1481       s = range();
1482       }
1483       if (!hasError) {
1484 return s;
1485       }
1486     } else if (jj_2_11(2147483647)) {
1487       if (!hasError) {
1488       s = simple_expression();
1489       }
1490       if (!hasError) {
1491 return s;
1492       }
1493     } else if (jj_2_12(2147483647)) {
1494       if (!hasError) {
1495       s = discrete_range();
1496       }
1497       if (!hasError) {
1498 return s;
1499       }
1500     } else {
1501       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1502       case BASIC_IDENTIFIER:
1503       case EXTENDED_CHARACTER:{
1504         if (!hasError) {
1505         s = identifier();
1506         }
1507         if (!hasError) {
1508 return s;
1509         }
1510         break;
1511         }
1512       case OTHER_T:{
1513         if (!hasError) {
1514         jj_consume_token(OTHER_T);
1515         }
1516         if (!hasError) {
1517 return " others ";
1518         }
1519         break;
1520         }
1521       default:
1522         jj_la1[43] = jj_gen;
1523         jj_consume_token(-1);
1524         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1525       }
1526     }
1527 assert(false);
1528 }
1529 
1530 
choices()1531 QCString VhdlParser::choices() {QCString s,s1;
1532     if (!hasError) {
1533     s = choice();
1534     }
1535     if (!hasError) {
1536     while (!hasError) {
1537       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1538       case BAR_T:{
1539         ;
1540         break;
1541         }
1542       default:
1543         jj_la1[44] = jj_gen;
1544         goto end_label_10;
1545       }
1546       if (!hasError) {
1547       jj_consume_token(BAR_T);
1548       }
1549       if (!hasError) {
1550       s1 = choice();
1551       }
1552       if (!hasError) {
1553 s+="|";s+=s1;
1554       }
1555     }
1556     end_label_10: ;
1557     }
1558 return s;
1559 assert(false);
1560 }
1561 
1562 
component_configuration()1563 void VhdlParser::component_configuration() {
1564     if (!hasError) {
1565     jj_consume_token(FOR_T);
1566     }
1567     if (!hasError) {
1568     component_specification();
1569     }
1570     if (!hasError) {
1571     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1572     case GENERIC_T:
1573     case PORT_T:
1574     case USE_T:
1575     case SEMI_T:{
1576       if (!hasError) {
1577       binding_indication();
1578       }
1579       if (!hasError) {
1580       jj_consume_token(SEMI_T);
1581       }
1582       break;
1583       }
1584     default:
1585       jj_la1[45] = jj_gen;
1586       ;
1587     }
1588     }
1589     if (!hasError) {
1590     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1591     case FOR_T:{
1592       if (!hasError) {
1593       block_configuration();
1594       }
1595       break;
1596       }
1597     default:
1598       jj_la1[46] = jj_gen;
1599       ;
1600     }
1601     }
1602     if (!hasError) {
1603     jj_consume_token(END_T);
1604     }
1605     if (!hasError) {
1606     jj_consume_token(FOR_T);
1607     }
1608     if (!hasError) {
1609     jj_consume_token(SEMI_T);
1610     }
1611 }
1612 
1613 
component_declaration()1614 void VhdlParser::component_declaration() {QCString s;
1615     if (!hasError) {
1616     jj_consume_token(COMPONENT_T);
1617     }
1618     if (!hasError) {
1619     s = identifier();
1620     }
1621     if (!hasError) {
1622     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1623     case IS_T:{
1624       if (!hasError) {
1625       jj_consume_token(IS_T);
1626       }
1627       break;
1628       }
1629     default:
1630       jj_la1[47] = jj_gen;
1631       ;
1632     }
1633     }
1634     if (!hasError) {
1635 m_sharedState->currP=VhdlDocGen::COMPONENT;
1636     }
1637     if (!hasError) {
1638     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1639     case GENERIC_T:{
1640       if (!hasError) {
1641       generic_clause();
1642       }
1643       break;
1644       }
1645     default:
1646       jj_la1[48] = jj_gen;
1647       ;
1648     }
1649     }
1650     if (!hasError) {
1651     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1652     case PORT_T:{
1653       if (!hasError) {
1654       port_clause();
1655       }
1656       break;
1657       }
1658     default:
1659       jj_la1[49] = jj_gen;
1660       ;
1661     }
1662     }
1663     if (!hasError) {
1664 outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
1665      m_sharedState->currP=0;
1666     }
1667     if (!hasError) {
1668     jj_consume_token(END_T);
1669     }
1670     if (!hasError) {
1671     jj_consume_token(COMPONENT_T);
1672     }
1673     if (!hasError) {
1674     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1675     case BASIC_IDENTIFIER:
1676     case EXTENDED_CHARACTER:{
1677       if (!hasError) {
1678       identifier();
1679       }
1680       break;
1681       }
1682     default:
1683       jj_la1[50] = jj_gen;
1684       ;
1685     }
1686     }
1687     if (!hasError) {
1688     jj_consume_token(SEMI_T);
1689     }
1690 }
1691 
1692 
component_instantiation_statement()1693 void VhdlParser::component_instantiation_statement() {QCString s,s1;
1694     if (!hasError) {
1695     s = identifier();
1696     }
1697     if (!hasError) {
1698     jj_consume_token(COLON_T);
1699     }
1700     if (!hasError) {
1701     s1 = instantiation_unit();
1702     }
1703     if (!hasError) {
1704 QCString s3;
1705        if (s1.contains("|")) {
1706          s3=VhdlDocGen::getIndexWord(s1,0);
1707          s1=VhdlDocGen::getIndexWord(s1,1);
1708        }
1709 
1710        outlineParser()->addCompInst(s.lower().data(),s1.lower().data(),s3.data(),outlineParser()->getLine());
1711     }
1712     if (!hasError) {
1713     if (jj_2_13(2147483647)) {
1714       if (!hasError) {
1715       generic_map_aspect();
1716       }
1717     } else {
1718       ;
1719     }
1720     }
1721     if (!hasError) {
1722     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1723     case PORT_T:{
1724       if (!hasError) {
1725       port_map_aspect();
1726       }
1727       break;
1728       }
1729     default:
1730       jj_la1[51] = jj_gen;
1731       ;
1732     }
1733     }
1734     if (!hasError) {
1735     jj_consume_token(SEMI_T);
1736     }
1737 }
1738 
1739 
component_specification()1740 void VhdlParser::component_specification() {
1741     if (!hasError) {
1742     instantiation_list();
1743     }
1744     if (!hasError) {
1745     jj_consume_token(COLON_T);
1746     }
1747     if (!hasError) {
1748     name();
1749     }
1750 }
1751 
1752 
composite_type_definition()1753 QCString VhdlParser::composite_type_definition() {QCString s,s1;
1754     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1755     case ARRAY_T:{
1756       if (!hasError) {
1757       s = array_type_definition();
1758       }
1759       if (!hasError) {
1760 return s;
1761       }
1762       break;
1763       }
1764     case RECORD_T:{
1765       if (!hasError) {
1766       record_type_definition();
1767       }
1768       if (!hasError) {
1769 return s+"#";
1770       }
1771       break;
1772       }
1773     default:
1774       jj_la1[52] = jj_gen;
1775       jj_consume_token(-1);
1776       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1777     }
1778 assert(false);
1779 }
1780 
1781 
concurrent_assertion_statement()1782 void VhdlParser::concurrent_assertion_statement() {
1783     if (!hasError) {
1784     if (jj_2_14(2)) {
1785       if (!hasError) {
1786       identifier();
1787       }
1788       if (!hasError) {
1789       jj_consume_token(COLON_T);
1790       }
1791     } else {
1792       ;
1793     }
1794     }
1795     if (!hasError) {
1796     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1797     case POSTPONED_T:{
1798       if (!hasError) {
1799       jj_consume_token(POSTPONED_T);
1800       }
1801       break;
1802       }
1803     default:
1804       jj_la1[53] = jj_gen;
1805       ;
1806     }
1807     }
1808     if (!hasError) {
1809     assertion();
1810     }
1811     if (!hasError) {
1812     jj_consume_token(SEMI_T);
1813     }
1814 }
1815 
1816 
concurrent_procedure_call_statement()1817 void VhdlParser::concurrent_procedure_call_statement() {
1818     if (!hasError) {
1819     if (jj_2_15(2)) {
1820       if (!hasError) {
1821       identifier();
1822       }
1823       if (!hasError) {
1824       jj_consume_token(COLON_T);
1825       }
1826     } else {
1827       ;
1828     }
1829     }
1830     if (!hasError) {
1831     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1832     case POSTPONED_T:{
1833       if (!hasError) {
1834       jj_consume_token(POSTPONED_T);
1835       }
1836       break;
1837       }
1838     default:
1839       jj_la1[54] = jj_gen;
1840       ;
1841     }
1842     }
1843     if (!hasError) {
1844     procedure_call();
1845     }
1846     if (!hasError) {
1847     jj_consume_token(SEMI_T);
1848     }
1849 }
1850 
1851 
concurrent_signal_assignment_statement()1852 void VhdlParser::concurrent_signal_assignment_statement() {
1853     if (!hasError) {
1854     if (jj_2_16(2)) {
1855       if (!hasError) {
1856       identifier();
1857       }
1858       if (!hasError) {
1859       jj_consume_token(COLON_T);
1860       }
1861     } else {
1862       ;
1863     }
1864     }
1865     if (!hasError) {
1866     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1867     case POSTPONED_T:{
1868       if (!hasError) {
1869       jj_consume_token(POSTPONED_T);
1870       }
1871       break;
1872       }
1873     default:
1874       jj_la1[55] = jj_gen;
1875       ;
1876     }
1877     }
1878     if (!hasError) {
1879     if (jj_2_17(2147483647)) {
1880       if (!hasError) {
1881       conditional_signal_assignment();
1882       }
1883     } else {
1884       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1885       case WITH_T:{
1886         if (!hasError) {
1887         selected_signal_assignment();
1888         }
1889         break;
1890         }
1891       default:
1892         jj_la1[56] = jj_gen;
1893         jj_consume_token(-1);
1894         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1895       }
1896     }
1897     }
1898 }
1899 
1900 
concurrent_statement()1901 void VhdlParser::concurrent_statement() {
1902     if (jj_2_18(2147483647)) {
1903       if (!hasError) {
1904       block_statement();
1905       }
1906     } else if (jj_2_19(2147483647)) {
1907       if (!hasError) {
1908       process_statement();
1909       }
1910     } else if (jj_2_20(3)) {
1911       if (!hasError) {
1912       generate_statement();
1913       }
1914     } else {
1915       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1916       case CASE_T:{
1917         if (!hasError) {
1918         case_scheme();
1919         }
1920         break;
1921         }
1922       default:
1923         jj_la1[57] = jj_gen;
1924         if (jj_2_21(2147483647)) {
1925           if (!hasError) {
1926           concurrent_assertion_statement();
1927           }
1928         } else if (jj_2_22(2147483647)) {
1929           if (!hasError) {
1930           concurrent_signal_assignment_statement();
1931           }
1932         } else if (jj_2_23(2147483647)) {
1933           if (!hasError) {
1934           component_instantiation_statement();
1935           }
1936         } else if (jj_2_24(2147483647)) {
1937           if (!hasError) {
1938           concurrent_procedure_call_statement();
1939           }
1940         } else {
1941           switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
1942           case VHDL2008TOOLDIR:{
1943             if (!hasError) {
1944             jj_consume_token(VHDL2008TOOLDIR);
1945             }
1946             break;
1947             }
1948           default:
1949             jj_la1[58] = jj_gen;
1950             jj_consume_token(-1);
1951             errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
1952           }
1953         }
1954       }
1955     }
1956 }
1957 
1958 
condition()1959 QCString VhdlParser::condition() {QCString s;
1960     if (!hasError) {
1961     s = expression();
1962     }
1963 return s;
1964 assert(false);
1965 }
1966 
1967 
condition_clause()1968 QCString VhdlParser::condition_clause() {QCString s;
1969     if (!hasError) {
1970     jj_consume_token(UNTIL_T);
1971     }
1972     if (!hasError) {
1973     s = condition();
1974     }
1975 return " until "+s;
1976 assert(false);
1977 }
1978 
1979 
conditional_signal_assignment()1980 void VhdlParser::conditional_signal_assignment() {
1981     if (!hasError) {
1982     target();
1983     }
1984     if (!hasError) {
1985     jj_consume_token(LESSTHAN_T);
1986     }
1987     if (!hasError) {
1988     options();
1989     }
1990     if (!hasError) {
1991     conditional_waveforms();
1992     }
1993     if (!hasError) {
1994     jj_consume_token(SEMI_T);
1995     }
1996 }
1997 
1998 
conditional_waveforms()1999 void VhdlParser::conditional_waveforms() {
2000     if (!hasError) {
2001     waveform();
2002     }
2003     if (!hasError) {
2004     while (!hasError) {
2005       if (jj_2_25(2147483647)) {
2006         ;
2007       } else {
2008         goto end_label_11;
2009       }
2010       if (!hasError) {
2011       jj_consume_token(WHEN_T);
2012       }
2013       if (!hasError) {
2014       condition();
2015       }
2016       if (!hasError) {
2017       jj_consume_token(ELSE_T);
2018       }
2019       if (!hasError) {
2020       waveform();
2021       }
2022     }
2023     end_label_11: ;
2024     }
2025     if (!hasError) {
2026     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2027     case WHEN_T:{
2028       if (!hasError) {
2029       jj_consume_token(WHEN_T);
2030       }
2031       if (!hasError) {
2032       condition();
2033       }
2034       break;
2035       }
2036     default:
2037       jj_la1[59] = jj_gen;
2038       ;
2039     }
2040     }
2041 }
2042 
2043 
configuration_declaration()2044 void VhdlParser::configuration_declaration() {QCString s,s1;
2045     if (!hasError) {
2046     jj_consume_token(CONFIGURATION_T);
2047     }
2048     if (!hasError) {
2049     s = identifier();
2050     }
2051     if (!hasError) {
2052     jj_consume_token(OF_T);
2053     }
2054     if (!hasError) {
2055     s1 = name();
2056     }
2057     if (!hasError) {
2058     jj_consume_token(IS_T);
2059     }
2060     if (!hasError) {
2061 m_sharedState->confName=s+"::"+s1;
2062   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
2063     }
2064     if (!hasError) {
2065     configuration_declarative_part();
2066     }
2067     if (!hasError) {
2068     block_configuration();
2069     }
2070     if (!hasError) {
2071     jj_consume_token(END_T);
2072     }
2073     if (!hasError) {
2074     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2075     case CONFIGURATION_T:{
2076       if (!hasError) {
2077       jj_consume_token(CONFIGURATION_T);
2078       }
2079       break;
2080       }
2081     default:
2082       jj_la1[60] = jj_gen;
2083       ;
2084     }
2085     }
2086     if (!hasError) {
2087     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2088     case SLSL_T:
2089     case STRINGLITERAL:
2090     case BASIC_IDENTIFIER:
2091     case EXTENDED_CHARACTER:{
2092       if (!hasError) {
2093       name();
2094       }
2095       break;
2096       }
2097     default:
2098       jj_la1[61] = jj_gen;
2099       ;
2100     }
2101     }
2102     if (!hasError) {
2103     jj_consume_token(SEMI_T);
2104     }
2105 m_sharedState->genLabels.resize(0); m_sharedState->confName="";
2106 }
2107 
2108 
configuration_declarative_item()2109 void VhdlParser::configuration_declarative_item() {
2110     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2111     case USE_T:{
2112       if (!hasError) {
2113       use_clause();
2114       }
2115       break;
2116       }
2117     case ATTRIBUTE_T:{
2118       if (!hasError) {
2119       attribute_specification();
2120       }
2121       break;
2122       }
2123     case GROUP_T:{
2124       if (!hasError) {
2125       group_declaration();
2126       }
2127       break;
2128       }
2129     default:
2130       jj_la1[62] = jj_gen;
2131       jj_consume_token(-1);
2132       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2133     }
2134 }
2135 
2136 
configuration_declarative_part()2137 void VhdlParser::configuration_declarative_part() {
2138     if (!hasError) {
2139     while (!hasError) {
2140       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2141       case ATTRIBUTE_T:
2142       case GROUP_T:
2143       case USE_T:{
2144         ;
2145         break;
2146         }
2147       default:
2148         jj_la1[63] = jj_gen;
2149         goto end_label_12;
2150       }
2151       if (!hasError) {
2152       configuration_declarative_item();
2153       }
2154     }
2155     end_label_12: ;
2156     }
2157 }
2158 
2159 
configuration_item()2160 void VhdlParser::configuration_item() {
2161     if (jj_2_26(2147483647)) {
2162       if (!hasError) {
2163       component_configuration();
2164       }
2165     } else {
2166       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2167       case FOR_T:{
2168         if (!hasError) {
2169         block_configuration();
2170         }
2171         break;
2172         }
2173       default:
2174         jj_la1[64] = jj_gen;
2175         jj_consume_token(-1);
2176         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2177       }
2178     }
2179 }
2180 
2181 
configuration_specification()2182 void VhdlParser::configuration_specification() {
2183     if (!hasError) {
2184     jj_consume_token(FOR_T);
2185     }
2186     if (!hasError) {
2187     component_specification();
2188     }
2189     if (!hasError) {
2190     binding_indication();
2191     }
2192     if (!hasError) {
2193     jj_consume_token(SEMI_T);
2194     }
2195 }
2196 
2197 
constant_declaration()2198 QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;
2199     if (!hasError) {
2200     jj_consume_token(CONSTANT_T);
2201     }
2202     if (!hasError) {
2203     s = identifier_list();
2204     }
2205     if (!hasError) {
2206     jj_consume_token(COLON_T);
2207     }
2208     if (!hasError) {
2209     s1 = subtype_indication();
2210     }
2211     if (!hasError) {
2212     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2213     case VARASSIGN_T:{
2214       if (!hasError) {
2215       t = jj_consume_token(VARASSIGN_T);
2216       }
2217       if (!hasError) {
2218       s2 = expression();
2219       }
2220       break;
2221       }
2222     default:
2223       jj_la1[65] = jj_gen;
2224       ;
2225     }
2226     }
2227     if (!hasError) {
2228     jj_consume_token(SEMI_T);
2229     }
2230 if(t)
2231       s2.prepend(":=");
2232      QCString it=s1+s2;
2233      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
2234      it.prepend("constant ");
2235      return it;
2236 assert(false);
2237 }
2238 
2239 
constraint_array_definition()2240 QCString VhdlParser::constraint_array_definition() {QCString s,s1;
2241     if (!hasError) {
2242     jj_consume_token(ARRAY_T);
2243     }
2244     if (!hasError) {
2245     s = index_constraint();
2246     }
2247     if (!hasError) {
2248     jj_consume_token(OF_T);
2249     }
2250     if (!hasError) {
2251     s1 = subtype_indication();
2252     }
2253 return s+" "+s1;
2254 assert(false);
2255 }
2256 
2257 
context_clause()2258 void VhdlParser::context_clause() {
2259     if (!hasError) {
2260     while (!hasError) {
2261       if (jj_2_27(3)) {
2262         ;
2263       } else {
2264         goto end_label_13;
2265       }
2266       if (!hasError) {
2267       context_item();
2268       }
2269     }
2270     end_label_13: ;
2271     }
2272 }
2273 
2274 
constraint()2275 QCString VhdlParser::constraint() {QCString s;
2276     if (jj_2_28(2147483647)) {
2277       if (!hasError) {
2278       s = range_constraint();
2279       }
2280       if (!hasError) {
2281 return s;
2282       }
2283     } else if (jj_2_29(2147483647)) {
2284       if (!hasError) {
2285       s = index_constraint();
2286       }
2287       if (!hasError) {
2288 return s;
2289       }
2290     } else {
2291       jj_consume_token(-1);
2292       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2293     }
2294 assert(false);
2295 }
2296 
2297 
context_item()2298 void VhdlParser::context_item() {
2299     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2300     case LIBRARY_T:{
2301       if (!hasError) {
2302       library_clause();
2303       }
2304       break;
2305       }
2306     case USE_T:{
2307       if (!hasError) {
2308       use_clause();
2309       }
2310       break;
2311       }
2312     default:
2313       jj_la1[66] = jj_gen;
2314       if (jj_2_30(2147483647)) {
2315         if (!hasError) {
2316         context_declaration();
2317         }
2318       } else {
2319         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2320         case CONTEXT_T:{
2321           if (!hasError) {
2322           context_ref();
2323           }
2324           break;
2325           }
2326         default:
2327           jj_la1[67] = jj_gen;
2328           jj_consume_token(-1);
2329           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2330         }
2331       }
2332     }
2333 }
2334 
2335 
decimal_literal()2336 QCString VhdlParser::decimal_literal() {Token *tok=0;
2337     if (!hasError) {
2338     tok = jj_consume_token(DECIMAL_LITERAL);
2339     }
2340 return QCString(tok->image);
2341 assert(false);
2342 }
2343 
2344 
delay_mechanism()2345 QCString VhdlParser::delay_mechanism() {QCString s;
2346     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2347     case TRANSPORT_T:{
2348       if (!hasError) {
2349       jj_consume_token(TRANSPORT_T);
2350       }
2351       if (!hasError) {
2352 return " transport ";
2353       }
2354       break;
2355       }
2356     case INERTIAL_T:
2357     case REJECT_T:{
2358       if (!hasError) {
2359       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2360       case REJECT_T:{
2361         if (!hasError) {
2362         jj_consume_token(REJECT_T);
2363         }
2364         if (!hasError) {
2365         s = expression();
2366         }
2367         if (!hasError) {
2368 s.prepend(" reject ");
2369         }
2370         break;
2371         }
2372       default:
2373         jj_la1[68] = jj_gen;
2374         ;
2375       }
2376       }
2377       if (!hasError) {
2378       jj_consume_token(INERTIAL_T);
2379       }
2380       if (!hasError) {
2381 return s+" inertial ";
2382       }
2383       break;
2384       }
2385     default:
2386       jj_la1[69] = jj_gen;
2387       jj_consume_token(-1);
2388       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2389     }
2390 assert(false);
2391 }
2392 
2393 
design_file()2394 void VhdlParser::design_file() {
2395     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2396     case ARCHITECTURE_T:
2397     case CONFIGURATION_T:
2398     case CONTEXT_T:
2399     case ENTITY_T:
2400     case LIBRARY_T:
2401     case PACKAGE_T:
2402     case USE_T:{
2403       if (!hasError) {
2404       while (!hasError) {
2405         if (!hasError) {
2406         design_unit();
2407         }
2408         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2409         case ARCHITECTURE_T:
2410         case CONFIGURATION_T:
2411         case CONTEXT_T:
2412         case ENTITY_T:
2413         case LIBRARY_T:
2414         case PACKAGE_T:
2415         case USE_T:{
2416           ;
2417           break;
2418           }
2419         default:
2420           jj_la1[70] = jj_gen;
2421           goto end_label_14;
2422         }
2423       }
2424       end_label_14: ;
2425       }
2426       if (!hasError) {
2427 
2428       }
2429       break;
2430       }
2431     case 0:{
2432       if (!hasError) {
2433       jj_consume_token(0);
2434       }
2435       break;
2436       }
2437     default:
2438       jj_la1[71] = jj_gen;
2439       jj_consume_token(-1);
2440       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2441     }
2442 }
2443 
2444 
design_unit()2445 void VhdlParser::design_unit() {
2446     if (!hasError) {
2447     context_clause();
2448     }
2449     if (!hasError) {
2450     library_unit();
2451     }
2452 }
2453 
2454 
designator()2455 QCString VhdlParser::designator() {QCString s;
2456     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2457     case BASIC_IDENTIFIER:
2458     case EXTENDED_CHARACTER:{
2459       if (!hasError) {
2460       s = identifier();
2461       }
2462       if (!hasError) {
2463 return s;
2464       }
2465       break;
2466       }
2467     case STRINGLITERAL:{
2468       if (!hasError) {
2469       s = operator_symbol();
2470       }
2471       if (!hasError) {
2472 return s;
2473       }
2474       break;
2475       }
2476     default:
2477       jj_la1[72] = jj_gen;
2478       jj_consume_token(-1);
2479       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2480     }
2481 assert(false);
2482 }
2483 
2484 
direction()2485 QCString VhdlParser::direction() {Token *tok=0;
2486     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2487     case TO_T:{
2488       if (!hasError) {
2489       tok = jj_consume_token(TO_T);
2490       }
2491       if (!hasError) {
2492 return QCString(tok->image);
2493       }
2494       break;
2495       }
2496     case DOWNTO_T:{
2497       if (!hasError) {
2498       tok = jj_consume_token(DOWNTO_T);
2499       }
2500       if (!hasError) {
2501 return QCString(tok->image);
2502       }
2503       break;
2504       }
2505     default:
2506       jj_la1[73] = jj_gen;
2507       jj_consume_token(-1);
2508       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2509     }
2510 assert(false);
2511 }
2512 
2513 
disconnection_specification()2514 void VhdlParser::disconnection_specification() {
2515     if (!hasError) {
2516     jj_consume_token(DISCONNECT_T);
2517     }
2518     if (!hasError) {
2519     guarded_signal_specificatio();
2520     }
2521     if (!hasError) {
2522     jj_consume_token(AFTER_T);
2523     }
2524     if (!hasError) {
2525     expression();
2526     }
2527     if (!hasError) {
2528     jj_consume_token(SEMI_T);
2529     }
2530 }
2531 
2532 
guarded_signal_specificatio()2533 void VhdlParser::guarded_signal_specificatio() {
2534     if (!hasError) {
2535     signal_list();
2536     }
2537     if (!hasError) {
2538     jj_consume_token(COLON_T);
2539     }
2540     if (!hasError) {
2541     name();
2542     }
2543 }
2544 
2545 
discrete_range()2546 QCString VhdlParser::discrete_range() {QCString s;
2547     if (jj_2_31(2147483647)) {
2548       if (!hasError) {
2549       s = range();
2550       }
2551       if (!hasError) {
2552 return s;
2553       }
2554     } else if (jj_2_32(2147483647)) {
2555       if (!hasError) {
2556       s = subtype_indication();
2557       }
2558       if (!hasError) {
2559 return s;
2560       }
2561     } else {
2562       jj_consume_token(-1);
2563       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2564     }
2565 assert(false);
2566 }
2567 
2568 
element_association()2569 QCString VhdlParser::element_association() {QCString s,s1;
2570     if (!hasError) {
2571     if (jj_2_33(2147483647)) {
2572       if (!hasError) {
2573       s = choices();
2574       }
2575       if (!hasError) {
2576       jj_consume_token(ARROW_T);
2577       }
2578     } else {
2579       ;
2580     }
2581     }
2582     if (!hasError) {
2583     s1 = expression();
2584     }
2585 if(!s.isEmpty())
2586  return s+"=>"+s1;
2587 return s1;
2588 assert(false);
2589 }
2590 
2591 
element_declaration()2592 QCString VhdlParser::element_declaration() {QCString rec_name,s1,s2;
2593     if (!hasError) {
2594     rec_name = identifier_list();
2595     }
2596     if (!hasError) {
2597     jj_consume_token(COLON_T);
2598     }
2599     if (!hasError) {
2600     s1 = subtype_indication();
2601     }
2602     if (!hasError) {
2603     jj_consume_token(SEMI_T);
2604     }
2605 auto ql = split(rec_name.str(),",");
2606     for (const auto &n : ql)
2607     {
2608       std::string name=n+"~";
2609       name+=outlineParser()->getNameID().data();
2610       outlineParser()->addVhdlType(
2611           name.c_str(),outlineParser()->getLine(),
2612           Entry::VARIABLE_SEC,
2613           VhdlDocGen::RECORD,0,
2614           s1.data(),
2615           Public);
2616     }
2617     s2=rec_name+":"+s1;
2618     return s2;
2619 assert(false);
2620 }
2621 
2622 
entity_aspect()2623 QCString VhdlParser::entity_aspect() {Token *tok=0;QCString s,s1;
2624     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2625     case ENTITY_T:{
2626       if (!hasError) {
2627       tok = jj_consume_token(ENTITY_T);
2628       }
2629       if (!hasError) {
2630       s = name();
2631       }
2632       if (!hasError) {
2633       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2634       case LPAREN_T:{
2635         if (!hasError) {
2636         jj_consume_token(LPAREN_T);
2637         }
2638         if (!hasError) {
2639         s1 = identifier();
2640         }
2641         if (!hasError) {
2642         jj_consume_token(RPAREN_T);
2643         }
2644         if (!hasError) {
2645 s+="("+s1+")";
2646         }
2647         break;
2648         }
2649       default:
2650         jj_la1[74] = jj_gen;
2651         ;
2652       }
2653       }
2654       if (!hasError) {
2655 return s;
2656       }
2657       break;
2658       }
2659     case CONFIGURATION_T:{
2660       if (!hasError) {
2661       tok = jj_consume_token(CONFIGURATION_T);
2662       }
2663       if (!hasError) {
2664       s = name();
2665       }
2666       if (!hasError) {
2667 return QCString(tok->image)+s;
2668       }
2669       break;
2670       }
2671     case OPEN_T:{
2672       if (!hasError) {
2673       tok = jj_consume_token(OPEN_T);
2674       }
2675       if (!hasError) {
2676 return QCString(tok->image);
2677       }
2678       break;
2679       }
2680     default:
2681       jj_la1[75] = jj_gen;
2682       jj_consume_token(-1);
2683       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2684     }
2685 assert(false);
2686 }
2687 
2688 
entity_class()2689 QCString VhdlParser::entity_class() {
2690     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2691     case ENTITY_T:{
2692       if (!hasError) {
2693       jj_consume_token(ENTITY_T);
2694       }
2695       if (!hasError) {
2696 return "entity";
2697       }
2698       break;
2699       }
2700     case ARCHITECTURE_T:{
2701       if (!hasError) {
2702       jj_consume_token(ARCHITECTURE_T);
2703       }
2704       if (!hasError) {
2705 return "architecture";
2706       }
2707       break;
2708       }
2709     case CONFIGURATION_T:{
2710       if (!hasError) {
2711       jj_consume_token(CONFIGURATION_T);
2712       }
2713       if (!hasError) {
2714 return "configuration";
2715       }
2716       break;
2717       }
2718     case PROCEDURE_T:{
2719       if (!hasError) {
2720       jj_consume_token(PROCEDURE_T);
2721       }
2722       if (!hasError) {
2723 return "procedure";
2724       }
2725       break;
2726       }
2727     case FUNCTION_T:{
2728       if (!hasError) {
2729       jj_consume_token(FUNCTION_T);
2730       }
2731       if (!hasError) {
2732 return "function";
2733       }
2734       break;
2735       }
2736     case PACKAGE_T:{
2737       if (!hasError) {
2738       jj_consume_token(PACKAGE_T);
2739       }
2740       if (!hasError) {
2741 return "package";
2742       }
2743       break;
2744       }
2745     case TYPE_T:{
2746       if (!hasError) {
2747       jj_consume_token(TYPE_T);
2748       }
2749       if (!hasError) {
2750 return "type";
2751       }
2752       break;
2753       }
2754     case SUBTYPE_T:{
2755       if (!hasError) {
2756       jj_consume_token(SUBTYPE_T);
2757       }
2758       if (!hasError) {
2759 return "subtype";
2760       }
2761       break;
2762       }
2763     case CONSTANT_T:{
2764       if (!hasError) {
2765       jj_consume_token(CONSTANT_T);
2766       }
2767       if (!hasError) {
2768 return "constant";
2769       }
2770       break;
2771       }
2772     case SIGNAL_T:{
2773       if (!hasError) {
2774       jj_consume_token(SIGNAL_T);
2775       }
2776       if (!hasError) {
2777 return "signal";
2778       }
2779       break;
2780       }
2781     case VARIABLE_T:{
2782       if (!hasError) {
2783       jj_consume_token(VARIABLE_T);
2784       }
2785       if (!hasError) {
2786 return "variable";
2787       }
2788       break;
2789       }
2790     case COMPONENT_T:{
2791       if (!hasError) {
2792       jj_consume_token(COMPONENT_T);
2793       }
2794       if (!hasError) {
2795 return "component";
2796       }
2797       break;
2798       }
2799     case LABEL_T:{
2800       if (!hasError) {
2801       jj_consume_token(LABEL_T);
2802       }
2803       if (!hasError) {
2804 return "label";
2805       }
2806       break;
2807       }
2808     case LITERAL_T:{
2809       if (!hasError) {
2810       jj_consume_token(LITERAL_T);
2811       }
2812       if (!hasError) {
2813 return "literal";
2814       }
2815       break;
2816       }
2817     case UNITS_T:{
2818       if (!hasError) {
2819       jj_consume_token(UNITS_T);
2820       }
2821       if (!hasError) {
2822 return "units";
2823       }
2824       break;
2825       }
2826     case GROUP_T:{
2827       if (!hasError) {
2828       jj_consume_token(GROUP_T);
2829       }
2830       if (!hasError) {
2831 return "group";
2832       }
2833       break;
2834       }
2835     case FILE_T:{
2836       if (!hasError) {
2837       jj_consume_token(FILE_T);
2838       }
2839       if (!hasError) {
2840 return "file";
2841       }
2842       break;
2843       }
2844     default:
2845       jj_la1[76] = jj_gen;
2846       jj_consume_token(-1);
2847       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
2848     }
2849 assert(false);
2850 }
2851 
2852 
entity_class_entry()2853 QCString VhdlParser::entity_class_entry() {QCString s;
2854     if (!hasError) {
2855     s = entity_class();
2856     }
2857     if (!hasError) {
2858     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2859     case BOX_T:{
2860       if (!hasError) {
2861       jj_consume_token(BOX_T);
2862       }
2863       if (!hasError) {
2864 s+="<>";
2865       }
2866       break;
2867       }
2868     default:
2869       jj_la1[77] = jj_gen;
2870       ;
2871     }
2872     }
2873 return s;
2874 assert(false);
2875 }
2876 
2877 
entity_class_entry_list()2878 QCString VhdlParser::entity_class_entry_list() {QCString s,s1,s2;
2879     if (!hasError) {
2880     if (!hasError) {
2881     s1 = entity_class_entry();
2882     }
2883     if (!hasError) {
2884 s+=s1;
2885     }
2886     }
2887     if (!hasError) {
2888     while (!hasError) {
2889       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2890       case COMMA_T:{
2891         ;
2892         break;
2893         }
2894       default:
2895         jj_la1[78] = jj_gen;
2896         goto end_label_15;
2897       }
2898       if (!hasError) {
2899       jj_consume_token(COMMA_T);
2900       }
2901       if (!hasError) {
2902       s = entity_class_entry();
2903       }
2904       if (!hasError) {
2905 s2+=",";s2+=s;
2906       }
2907     }
2908     end_label_15: ;
2909     }
2910 return s1+s2;
2911 assert(false);
2912 }
2913 
2914 
entity_declaration()2915 void VhdlParser::entity_declaration() {QCString s;
2916     if (!hasError) {
2917     jj_consume_token(ENTITY_T);
2918     }
2919     if (!hasError) {
2920     s = identifier();
2921     }
2922     if (!hasError) {
2923     jj_consume_token(IS_T);
2924     }
2925     if (!hasError) {
2926 m_sharedState->lastEntity=m_sharedState->current;
2927                 m_sharedState->lastCompound=0;
2928                 outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
2929     }
2930     if (!hasError) {
2931     entity_header();
2932     }
2933     if (!hasError) {
2934     entity_declarative_part();
2935     }
2936     if (!hasError) {
2937     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2938     case BEGIN_T:{
2939       if (!hasError) {
2940       jj_consume_token(BEGIN_T);
2941       }
2942       if (!hasError) {
2943       entity_statement_part();
2944       }
2945       break;
2946       }
2947     default:
2948       jj_la1[79] = jj_gen;
2949       ;
2950     }
2951     }
2952     if (!hasError) {
2953     jj_consume_token(END_T);
2954     }
2955     if (!hasError) {
2956     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2957     case ENTITY_T:{
2958       if (!hasError) {
2959       jj_consume_token(ENTITY_T);
2960       }
2961       break;
2962       }
2963     default:
2964       jj_la1[80] = jj_gen;
2965       ;
2966     }
2967     }
2968     if (!hasError) {
2969     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2970     case SLSL_T:
2971     case STRINGLITERAL:
2972     case BASIC_IDENTIFIER:
2973     case EXTENDED_CHARACTER:{
2974       if (!hasError) {
2975       name();
2976       }
2977       break;
2978       }
2979     default:
2980       jj_la1[81] = jj_gen;
2981       ;
2982     }
2983     }
2984     if (!hasError) {
2985     jj_consume_token(SEMI_T);
2986     }
2987 m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
2988 }
2989 
2990 
entity_declarative_item()2991 void VhdlParser::entity_declarative_item() {
2992     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
2993     case FUNCTION_T:
2994     case IMPURE_T:
2995     case PROCEDURE_T:
2996     case PURE_T:{
2997       if (!hasError) {
2998       subprogram_declaration();
2999       }
3000       break;
3001       }
3002     case TYPE_T:{
3003       if (!hasError) {
3004       type_declaration();
3005       }
3006       break;
3007       }
3008     case SUBTYPE_T:{
3009       if (!hasError) {
3010       subtype_declaration();
3011       }
3012       break;
3013       }
3014     case CONSTANT_T:{
3015       if (!hasError) {
3016       constant_declaration();
3017       }
3018       break;
3019       }
3020     case SIGNAL_T:{
3021       if (!hasError) {
3022       signal_declaration();
3023       }
3024       break;
3025       }
3026     case SHARED_T:
3027     case VARIABLE_T:{
3028       if (!hasError) {
3029       variable_declaration();
3030       }
3031       break;
3032       }
3033     case FILE_T:{
3034       if (!hasError) {
3035       file_declaration();
3036       }
3037       break;
3038       }
3039     case ALIAS_T:{
3040       if (!hasError) {
3041       alias_declaration();
3042       }
3043       break;
3044       }
3045     default:
3046       jj_la1[82] = jj_gen;
3047       if (jj_2_34(2147483647)) {
3048         if (!hasError) {
3049         attribute_declaration();
3050         }
3051       } else {
3052         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3053         case ATTRIBUTE_T:{
3054           if (!hasError) {
3055           attribute_specification();
3056           }
3057           break;
3058           }
3059         case DISCONNECT_T:{
3060           if (!hasError) {
3061           disconnection_specification();
3062           }
3063           break;
3064           }
3065         case USE_T:{
3066           if (!hasError) {
3067           use_clause();
3068           }
3069           break;
3070           }
3071         default:
3072           jj_la1[83] = jj_gen;
3073           if (jj_2_35(3)) {
3074             if (!hasError) {
3075             group_template_declaration();
3076             }
3077           } else {
3078             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3079             case GROUP_T:{
3080               if (!hasError) {
3081               group_declaration();
3082               }
3083               break;
3084               }
3085             default:
3086               jj_la1[84] = jj_gen;
3087               if (jj_2_36(5)) {
3088                 if (!hasError) {
3089                 package_instantiation_declaration();
3090                 }
3091               } else {
3092                 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3093                 case PACKAGE_T:{
3094                   if (!hasError) {
3095                   package_declaration();
3096                   }
3097                   break;
3098                   }
3099                 case VHDL2008TOOLDIR:{
3100                   if (!hasError) {
3101                   jj_consume_token(VHDL2008TOOLDIR);
3102                   }
3103                   break;
3104                   }
3105                 default:
3106                   jj_la1[85] = jj_gen;
3107                   jj_consume_token(-1);
3108                   errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3109                 }
3110               }
3111             }
3112           }
3113         }
3114       }
3115     }
3116 }
3117 
3118 
entity_declarative_part()3119 void VhdlParser::entity_declarative_part() {
3120     if (!hasError) {
3121     while (!hasError) {
3122       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3123       case ALIAS_T:
3124       case ATTRIBUTE_T:
3125       case CONSTANT_T:
3126       case DISCONNECT_T:
3127       case FILE_T:
3128       case FUNCTION_T:
3129       case GROUP_T:
3130       case IMPURE_T:
3131       case PACKAGE_T:
3132       case PROCEDURE_T:
3133       case PURE_T:
3134       case SIGNAL_T:
3135       case SHARED_T:
3136       case SUBTYPE_T:
3137       case TYPE_T:
3138       case USE_T:
3139       case VARIABLE_T:
3140       case VHDL2008TOOLDIR:{
3141         ;
3142         break;
3143         }
3144       default:
3145         jj_la1[86] = jj_gen;
3146         goto end_label_16;
3147       }
3148       if (!hasError) {
3149       entity_declarative_item();
3150       }
3151     }
3152     end_label_16: ;
3153     }
3154 }
3155 
3156 
entity_designator()3157 QCString VhdlParser::entity_designator() {QCString s,s1;
3158     if (!hasError) {
3159     s = entity_tag();
3160     }
3161     if (!hasError) {
3162     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3163     case LBRACKET_T:{
3164       if (!hasError) {
3165       s1 = signature();
3166       }
3167       break;
3168       }
3169     default:
3170       jj_la1[87] = jj_gen;
3171       ;
3172     }
3173     }
3174 return s+s1;
3175 assert(false);
3176 }
3177 
3178 
entity_header()3179 void VhdlParser::entity_header() {
3180     if (!hasError) {
3181     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3182     case GENERIC_T:{
3183       if (!hasError) {
3184 m_sharedState->currP=VhdlDocGen::GENERIC;m_sharedState->parse_sec=GEN_SEC;
3185       }
3186       if (!hasError) {
3187       generic_clause();
3188       }
3189       break;
3190       }
3191     default:
3192       jj_la1[88] = jj_gen;
3193       ;
3194     }
3195     }
3196     if (!hasError) {
3197     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3198     case PORT_T:{
3199       if (!hasError) {
3200 m_sharedState->currP=VhdlDocGen::PORT;
3201       }
3202       if (!hasError) {
3203       port_clause();
3204       }
3205       break;
3206       }
3207     default:
3208       jj_la1[89] = jj_gen;
3209       ;
3210     }
3211     }
3212 }
3213 
3214 
entity_name_list()3215 QCString VhdlParser::entity_name_list() {QCString s,s1,s2;
3216     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3217     case SLSL_T:
3218     case STRINGLITERAL:
3219     case BASIC_IDENTIFIER:
3220     case EXTENDED_CHARACTER:
3221     case CHARACTER_LITERAL:{
3222       if (!hasError) {
3223       if (!hasError) {
3224       s1 = entity_designator();
3225       }
3226       }
3227       if (!hasError) {
3228       while (!hasError) {
3229         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3230         case COMMA_T:{
3231           ;
3232           break;
3233           }
3234         default:
3235           jj_la1[90] = jj_gen;
3236           goto end_label_17;
3237         }
3238         if (!hasError) {
3239         jj_consume_token(COMMA_T);
3240         }
3241         if (!hasError) {
3242         s = entity_designator();
3243         }
3244         if (!hasError) {
3245 s2+=s;
3246         }
3247       }
3248       end_label_17: ;
3249       }
3250       if (!hasError) {
3251 return s2;
3252       }
3253       break;
3254       }
3255     case OTHER_T:{
3256       if (!hasError) {
3257       jj_consume_token(OTHER_T);
3258       }
3259       if (!hasError) {
3260 return "other";
3261       }
3262       break;
3263       }
3264     case ALL_T:{
3265       if (!hasError) {
3266       jj_consume_token(ALL_T);
3267       }
3268       if (!hasError) {
3269 return "all";
3270       }
3271       break;
3272       }
3273     default:
3274       jj_la1[91] = jj_gen;
3275       jj_consume_token(-1);
3276       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3277     }
3278 assert(false);
3279 }
3280 
3281 
entity_specification()3282 QCString VhdlParser::entity_specification() {QCString s,s1;
3283     if (!hasError) {
3284     s = entity_name_list();
3285     }
3286     if (!hasError) {
3287     jj_consume_token(COLON_T);
3288     }
3289     if (!hasError) {
3290     s1 = entity_class();
3291     }
3292 return s+":"+s1;
3293 assert(false);
3294 }
3295 
3296 
entity_statement()3297 void VhdlParser::entity_statement() {
3298     if (jj_2_37(2147483647)) {
3299       if (!hasError) {
3300       concurrent_assertion_statement();
3301       }
3302     } else if (jj_2_38(2147483647)) {
3303       if (!hasError) {
3304       process_statement();
3305       }
3306     } else {
3307       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3308       case POSTPONED_T:
3309       case SLSL_T:
3310       case STRINGLITERAL:
3311       case BASIC_IDENTIFIER:
3312       case EXTENDED_CHARACTER:{
3313         if (!hasError) {
3314         concurrent_procedure_call_statement();
3315         }
3316         break;
3317         }
3318       default:
3319         jj_la1[92] = jj_gen;
3320         jj_consume_token(-1);
3321         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3322       }
3323     }
3324 }
3325 
3326 
entity_statement_part()3327 void VhdlParser::entity_statement_part() {
3328     if (!hasError) {
3329     while (!hasError) {
3330       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3331       case ASSERT_T:
3332       case POSTPONED_T:
3333       case PROCESS_T:
3334       case SLSL_T:
3335       case STRINGLITERAL:
3336       case BASIC_IDENTIFIER:
3337       case EXTENDED_CHARACTER:{
3338         ;
3339         break;
3340         }
3341       default:
3342         jj_la1[93] = jj_gen;
3343         goto end_label_18;
3344       }
3345       if (!hasError) {
3346       entity_statement();
3347       }
3348     }
3349     end_label_18: ;
3350     }
3351 }
3352 
3353 
entity_tag()3354 QCString VhdlParser::entity_tag() {QCString s;
3355     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3356     case SLSL_T:
3357     case STRINGLITERAL:
3358     case BASIC_IDENTIFIER:
3359     case EXTENDED_CHARACTER:{
3360       if (!hasError) {
3361       s = name();
3362       }
3363       if (!hasError) {
3364 return s;
3365       }
3366       break;
3367       }
3368     case CHARACTER_LITERAL:{
3369       if (!hasError) {
3370       s = character_literal();
3371       }
3372       if (!hasError) {
3373 return s;
3374       }
3375       break;
3376       }
3377     default:
3378       jj_la1[94] = jj_gen;
3379       jj_consume_token(-1);
3380       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3381     }
3382 assert(false);
3383 }
3384 
3385 
enumeration_literal()3386 QCString VhdlParser::enumeration_literal() {QCString s;
3387     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3388     case BASIC_IDENTIFIER:
3389     case EXTENDED_CHARACTER:{
3390       if (!hasError) {
3391       s = identifier();
3392       }
3393       if (!hasError) {
3394 return s;
3395       }
3396       break;
3397       }
3398     case CHARACTER_LITERAL:{
3399       if (!hasError) {
3400       s = character_literal();
3401       }
3402       if (!hasError) {
3403 return s;
3404       }
3405       break;
3406       }
3407     default:
3408       jj_la1[95] = jj_gen;
3409       jj_consume_token(-1);
3410       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3411     }
3412 assert(false);
3413 }
3414 
3415 
enumeration_type_definition()3416 QCString VhdlParser::enumeration_type_definition() {QCString s,s1;
3417     if (!hasError) {
3418     jj_consume_token(LPAREN_T);
3419     }
3420     if (!hasError) {
3421     s = enumeration_literal();
3422     }
3423     if (!hasError) {
3424     while (!hasError) {
3425       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3426       case COMMA_T:{
3427         ;
3428         break;
3429         }
3430       default:
3431         jj_la1[96] = jj_gen;
3432         goto end_label_19;
3433       }
3434       if (!hasError) {
3435       jj_consume_token(COMMA_T);
3436       }
3437       if (!hasError) {
3438       s1 = enumeration_literal();
3439       }
3440       if (!hasError) {
3441 s+=",";s+=s1;
3442       }
3443     }
3444     end_label_19: ;
3445     }
3446     if (!hasError) {
3447     jj_consume_token(RPAREN_T);
3448     }
3449 return "("+s+")";
3450 assert(false);
3451 }
3452 
3453 
exit_statement()3454 QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
3455     if (!hasError) {
3456     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3457     case BASIC_IDENTIFIER:
3458     case EXTENDED_CHARACTER:{
3459       if (!hasError) {
3460       s = identifier();
3461       }
3462       if (!hasError) {
3463       t = jj_consume_token(COLON_T);
3464       }
3465       break;
3466       }
3467     default:
3468       jj_la1[97] = jj_gen;
3469       ;
3470     }
3471     }
3472     if (!hasError) {
3473     jj_consume_token(EXIT_T);
3474     }
3475     if (!hasError) {
3476     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3477     case BASIC_IDENTIFIER:
3478     case EXTENDED_CHARACTER:{
3479       if (!hasError) {
3480       s1 = identifier();
3481       }
3482       break;
3483       }
3484     default:
3485       jj_la1[98] = jj_gen;
3486       ;
3487     }
3488     }
3489     if (!hasError) {
3490     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3491     case WHEN_T:{
3492       if (!hasError) {
3493       t1 = jj_consume_token(WHEN_T);
3494       }
3495       if (!hasError) {
3496       s2 = condition();
3497       }
3498       break;
3499       }
3500     default:
3501       jj_la1[99] = jj_gen;
3502       ;
3503     }
3504     }
3505     if (!hasError) {
3506     jj_consume_token(SEMI_T);
3507     }
3508 m_sharedState->lab.resize(0);
3509   if(t) s+=":";
3510   if(t1) s2.prepend(" when ");
3511    FlowChart::addFlowChart(FlowChart::EXIT_NO,"exit",s2,s1);
3512 
3513   return s+s1+s2+";";
3514 assert(false);
3515 }
3516 
3517 
expression()3518 QCString VhdlParser::expression() {QCString s,s1,s2;
3519     if (!hasError) {
3520     s = relation();
3521     }
3522     if (!hasError) {
3523     while (!hasError) {
3524       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3525       case AND_T:
3526       case NAND_T:
3527       case NOR_T:
3528       case OR_T:
3529       case XOR_T:
3530       case XNOR_T:{
3531         ;
3532         break;
3533         }
3534       default:
3535         jj_la1[100] = jj_gen;
3536         goto end_label_20;
3537       }
3538       if (!hasError) {
3539       s1 = logop();
3540       }
3541       if (!hasError) {
3542       s2 = relation();
3543       }
3544       if (!hasError) {
3545 s+=s1;s+=s2;
3546       }
3547     }
3548     end_label_20: ;
3549     }
3550 return s;
3551 assert(false);
3552 }
3553 
3554 
logop()3555 QCString VhdlParser::logop() {
3556     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3557     case AND_T:{
3558       if (!hasError) {
3559       jj_consume_token(AND_T);
3560       }
3561       if (!hasError) {
3562 return "and" ;
3563       }
3564       break;
3565       }
3566     case NAND_T:{
3567       if (!hasError) {
3568       jj_consume_token(NAND_T);
3569       }
3570       if (!hasError) {
3571 return "nand" ;
3572       }
3573       break;
3574       }
3575     case NOR_T:{
3576       if (!hasError) {
3577       jj_consume_token(NOR_T);
3578       }
3579       if (!hasError) {
3580 return "nor" ;
3581       }
3582       break;
3583       }
3584     case XNOR_T:{
3585       if (!hasError) {
3586       jj_consume_token(XNOR_T);
3587       }
3588       if (!hasError) {
3589 return "xnor" ;
3590       }
3591       break;
3592       }
3593     case XOR_T:{
3594       if (!hasError) {
3595       jj_consume_token(XOR_T);
3596       }
3597       if (!hasError) {
3598 return "xor" ;
3599       }
3600       break;
3601       }
3602     case OR_T:{
3603       if (!hasError) {
3604       jj_consume_token(OR_T);
3605       }
3606       if (!hasError) {
3607 return "or" ;
3608       }
3609       break;
3610       }
3611     default:
3612       jj_la1[101] = jj_gen;
3613       jj_consume_token(-1);
3614       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3615     }
3616 assert(false);
3617 }
3618 
3619 
extended_identifier()3620 QCString VhdlParser::extended_identifier() {Token *t;
3621     if (!hasError) {
3622     t = jj_consume_token(EXTENDED_CHARACTER);
3623     }
3624 return QCString(t->image);
3625 assert(false);
3626 }
3627 
3628 
factor()3629 QCString VhdlParser::factor() {QCString s,s1;
3630     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3631     case NEW_T:
3632     case NULL_T:
3633     case LPAREN_T:
3634     case SLSL_T:
3635     case INTEGER:
3636     case STRINGLITERAL:
3637     case BASIC_IDENTIFIER:
3638     case EXTENDED_CHARACTER:
3639     case CHARACTER_LITERAL:
3640     case DECIMAL_LITERAL:
3641     case BASED_LITERAL:
3642     case BIT_STRING_LITERAL:{
3643       if (!hasError) {
3644       s = primary();
3645       }
3646       if (!hasError) {
3647       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3648       case DOUBLEMULT_T:{
3649         if (!hasError) {
3650         jj_consume_token(DOUBLEMULT_T);
3651         }
3652         if (!hasError) {
3653         s1 = primary();
3654         }
3655         if (!hasError) {
3656 s+="**";s+=s1;
3657         }
3658         break;
3659         }
3660       default:
3661         jj_la1[102] = jj_gen;
3662         ;
3663       }
3664       }
3665       if (!hasError) {
3666 return s;
3667       }
3668       break;
3669       }
3670     case ABS_T:{
3671       if (!hasError) {
3672       jj_consume_token(ABS_T);
3673       }
3674       if (!hasError) {
3675       s = primary();
3676       }
3677       if (!hasError) {
3678 s1 = "abs "; return s1+s;
3679       }
3680       break;
3681       }
3682     case NOT_T:{
3683       if (!hasError) {
3684       jj_consume_token(NOT_T);
3685       }
3686       if (!hasError) {
3687       s = primary();
3688       }
3689       if (!hasError) {
3690 s1="not ";return s1+s;
3691       }
3692       break;
3693       }
3694     case QQ_T:{
3695       if (!hasError) {
3696       jj_consume_token(QQ_T);
3697       }
3698       if (!hasError) {
3699       s = primary();
3700       }
3701       if (!hasError) {
3702 s1="?? ";return s1;
3703       }
3704       break;
3705       }
3706     case AND_T:
3707     case NAND_T:
3708     case NOR_T:
3709     case OR_T:
3710     case XOR_T:
3711     case XNOR_T:{
3712       if (!hasError) {
3713       s = logop();
3714       }
3715       if (!hasError) {
3716       s1 = primary();
3717       }
3718       if (!hasError) {
3719 return s;
3720       }
3721       break;
3722       }
3723     default:
3724       jj_la1[103] = jj_gen;
3725       jj_consume_token(-1);
3726       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3727     }
3728 assert(false);
3729 }
3730 
3731 
file_declaration()3732 QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;
3733     if (!hasError) {
3734     jj_consume_token(FILE_T);
3735     }
3736     if (!hasError) {
3737     s = identifier_list();
3738     }
3739     if (!hasError) {
3740     jj_consume_token(COLON_T);
3741     }
3742     if (!hasError) {
3743     s2 = subtype_indication();
3744     }
3745     if (!hasError) {
3746     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3747     case IS_T:
3748     case OPEN_T:{
3749       if (!hasError) {
3750       s3 = file_open_information();
3751       }
3752       break;
3753       }
3754     default:
3755       jj_la1[104] = jj_gen;
3756       ;
3757     }
3758     }
3759     if (!hasError) {
3760     jj_consume_token(SEMI_T);
3761     }
3762 QCString t1=s2+" "+s3;
3763    outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
3764    return " file "+s+":"+s2+" "+s3+";";
3765 assert(false);
3766 }
3767 
3768 
file_logical_name()3769 QCString VhdlParser::file_logical_name() {QCString s;
3770     if (!hasError) {
3771     s = expression();
3772     }
3773 return s;
3774 assert(false);
3775 }
3776 
3777 
file_open_information()3778 QCString VhdlParser::file_open_information() {QCString s,s1,s2;
3779     if (!hasError) {
3780     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3781     case OPEN_T:{
3782       if (!hasError) {
3783       jj_consume_token(OPEN_T);
3784       }
3785       if (!hasError) {
3786       s = expression();
3787       }
3788       break;
3789       }
3790     default:
3791       jj_la1[105] = jj_gen;
3792       ;
3793     }
3794     }
3795     if (!hasError) {
3796     jj_consume_token(IS_T);
3797     }
3798     if (!hasError) {
3799     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3800     case IN_T:
3801     case OUT_T:{
3802       if (!hasError) {
3803       inout_stat();
3804       }
3805       break;
3806       }
3807     default:
3808       jj_la1[106] = jj_gen;
3809       ;
3810     }
3811     }
3812     if (!hasError) {
3813     s1 = file_logical_name();
3814     }
3815 s2="open "+s+" is "+s1;  return s2;
3816 assert(false);
3817 }
3818 
3819 
file_type_definition()3820 QCString VhdlParser::file_type_definition() {QCString s,s1;
3821     if (!hasError) {
3822     jj_consume_token(FILE_T);
3823     }
3824     if (!hasError) {
3825     jj_consume_token(OF_T);
3826     }
3827     if (!hasError) {
3828     s = type_mark();
3829     }
3830 s1=" file of "+s; return s1;
3831 assert(false);
3832 }
3833 
3834 
floating_type_definition()3835 QCString VhdlParser::floating_type_definition() {QCString s;
3836     if (!hasError) {
3837     s = range_constraint();
3838     }
3839 return s;
3840 assert(false);
3841 }
3842 
3843 
formal_designator()3844 QCString VhdlParser::formal_designator() {QCString s;Token *tok=0;
3845     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3846     case SLSL_T:
3847     case STRINGLITERAL:
3848     case BASIC_IDENTIFIER:
3849     case EXTENDED_CHARACTER:{
3850       if (!hasError) {
3851       s = name();
3852       }
3853       if (!hasError) {
3854 return s;
3855       }
3856       break;
3857       }
3858     case INTEGER:{
3859       if (!hasError) {
3860       tok = jj_consume_token(INTEGER);
3861       }
3862       if (!hasError) {
3863 return QCString(tok->image);
3864       }
3865       break;
3866       }
3867     default:
3868       jj_la1[107] = jj_gen;
3869       jj_consume_token(-1);
3870       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
3871     }
3872 assert(false);
3873 }
3874 
3875 
formal_parameter_list()3876 QCString VhdlParser::formal_parameter_list() {QCString s;
3877     if (!hasError) {
3878     s = interface_list();
3879     }
3880 return s;
3881 assert(false);
3882 }
3883 
3884 
formal_part()3885 QCString VhdlParser::formal_part() {QCString s,s1;
3886     if (!hasError) {
3887     s = name();
3888     }
3889     if (!hasError) {
3890     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
3891     case LPAREN_T:{
3892       if (!hasError) {
3893       jj_consume_token(LPAREN_T);
3894       }
3895       if (!hasError) {
3896       formal_designator();
3897       }
3898       if (!hasError) {
3899       jj_consume_token(RPAREN_T);
3900       }
3901       if (!hasError) {
3902 s+"("+s1+")";
3903       }
3904       break;
3905       }
3906     default:
3907       jj_la1[108] = jj_gen;
3908       ;
3909     }
3910     }
3911 return s;
3912 assert(false);
3913 }
3914 
3915 
full_type_declaration()3916 QCString VhdlParser::full_type_declaration() {std::shared_ptr<Entry> tmpEntry;QCString s,s1,s2;
3917     if (!hasError) {
3918     jj_consume_token(TYPE_T);
3919     }
3920     if (!hasError) {
3921     s = identifier();
3922     }
3923     if (!hasError) {
3924     jj_consume_token(IS_T);
3925     }
3926     if (!hasError) {
3927 tmpEntry=m_sharedState->current;
3928     outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
3929     }
3930     if (!hasError) {
3931     s2 = type_definition();
3932     }
3933     if (!hasError) {
3934     jj_consume_token(SEMI_T);
3935     }
3936 if (s2.contains("#")) {
3937       VhdlDocGen::deleteAllChars(s2,'#');
3938       tmpEntry->spec=VhdlDocGen::RECORD;
3939       tmpEntry->type=s2.data();
3940     }
3941     else if (s2.contains("%")) {
3942       VhdlDocGen::deleteAllChars(s2,'%');
3943       tmpEntry->spec=VhdlDocGen::UNITS;
3944       tmpEntry->type=s2.data();
3945      }
3946     else {
3947       tmpEntry->spec=VhdlDocGen::TYPE;
3948       tmpEntry->type=s2.data();
3949     }
3950 
3951     tmpEntry.reset();
3952     return "type "+s+" is "+s2+";";
3953 assert(false);
3954 }
3955 
3956 
function_call()3957 QCString VhdlParser::function_call() {QCString s,s1;
3958     if (!hasError) {
3959     s = name();
3960     }
3961     if (!hasError) {
3962     jj_consume_token(LPAREN_T);
3963     }
3964     if (!hasError) {
3965     s1 = actual_parameter_part();
3966     }
3967     if (!hasError) {
3968     jj_consume_token(RPAREN_T);
3969     }
3970 return s+"("+s1+")";
3971 assert(false);
3972 }
3973 
3974 
generate_statement()3975 void VhdlParser::generate_statement() {QCString s;
3976     if (!hasError) {
3977     s = identifier();
3978     }
3979     if (!hasError) {
3980     jj_consume_token(COLON_T);
3981     }
3982     if (!hasError) {
3983     try {
3984       if (!hasError) {
3985       generate_scheme();
3986       }
3987       if (!hasError) {
3988       jj_consume_token(GENERATE_T);
3989       }
3990       if (!hasError) {
3991 outlineParser()->pushLabel(m_sharedState->genLabels,s);
3992       }
3993       if (!hasError) {
3994       generate_statement_body1();
3995       }
3996       if (!hasError) {
3997       jj_consume_token(END_T);
3998       }
3999     } catch ( ...) {
4000 outlineParser()->error_skipto(GENERATE_T);
4001     }
4002     }
4003     if (!hasError) {
4004     jj_consume_token(GENERATE_T);
4005     }
4006     if (!hasError) {
4007     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4008     case BASIC_IDENTIFIER:
4009     case EXTENDED_CHARACTER:{
4010       if (!hasError) {
4011       identifier();
4012       }
4013       break;
4014       }
4015     default:
4016       jj_la1[109] = jj_gen;
4017       ;
4018     }
4019     }
4020     if (!hasError) {
4021     jj_consume_token(SEMI_T);
4022     }
4023 m_sharedState->genLabels=outlineParser()->popLabel(m_sharedState->genLabels);
4024 }
4025 
4026 
generate_scheme()4027 void VhdlParser::generate_scheme() {
4028     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4029     case FOR_T:{
4030       if (!hasError) {
4031       jj_consume_token(FOR_T);
4032       }
4033       if (!hasError) {
4034       parameter_specification();
4035       }
4036       break;
4037       }
4038     case IF_T:{
4039       if (!hasError) {
4040       jj_consume_token(IF_T);
4041       }
4042       if (!hasError) {
4043       if (jj_2_39(2)) {
4044         if (!hasError) {
4045         identifier();
4046         }
4047         if (!hasError) {
4048         jj_consume_token(COLON_T);
4049         }
4050       } else {
4051         ;
4052       }
4053       }
4054       if (!hasError) {
4055       condition();
4056       }
4057       break;
4058       }
4059     default:
4060       jj_la1[110] = jj_gen;
4061       jj_consume_token(-1);
4062       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4063     }
4064 }
4065 
4066 
generic_clause()4067 void VhdlParser::generic_clause() {QCString s;
4068     if (!hasError) {
4069     jj_consume_token(GENERIC_T);
4070     }
4071     if (!hasError) {
4072     jj_consume_token(LPAREN_T);
4073     }
4074     if (!hasError) {
4075 m_sharedState->parse_sec=GEN_SEC;
4076     }
4077     if (!hasError) {
4078     s = generic_list();
4079     }
4080     if (!hasError) {
4081     jj_consume_token(RPAREN_T);
4082     }
4083     if (!hasError) {
4084     jj_consume_token(SEMI_T);
4085     }
4086 m_sharedState->parse_sec=0;
4087 }
4088 
4089 
generic_list()4090 QCString VhdlParser::generic_list() {QCString s;
4091     if (!hasError) {
4092     s = interface_list();
4093     }
4094 return s;
4095 assert(false);
4096 }
4097 
4098 
generic_map_aspect()4099 void VhdlParser::generic_map_aspect() {
4100     if (!hasError) {
4101     jj_consume_token(GENERIC_T);
4102     }
4103     if (!hasError) {
4104     jj_consume_token(MAP_T);
4105     }
4106     if (!hasError) {
4107     jj_consume_token(LPAREN_T);
4108     }
4109     if (!hasError) {
4110     association_list();
4111     }
4112     if (!hasError) {
4113     jj_consume_token(RPAREN_T);
4114     }
4115 }
4116 
4117 
group_constituent()4118 QCString VhdlParser::group_constituent() {QCString s;
4119     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4120     case SLSL_T:
4121     case STRINGLITERAL:
4122     case BASIC_IDENTIFIER:
4123     case EXTENDED_CHARACTER:{
4124       if (!hasError) {
4125       s = name();
4126       }
4127       if (!hasError) {
4128 return s;
4129       }
4130       break;
4131       }
4132     case CHARACTER_LITERAL:{
4133       if (!hasError) {
4134       s = character_literal();
4135       }
4136       if (!hasError) {
4137 return s;
4138       }
4139       break;
4140       }
4141     default:
4142       jj_la1[111] = jj_gen;
4143       jj_consume_token(-1);
4144       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4145     }
4146 assert(false);
4147 }
4148 
4149 
group_constituent_list()4150 QCString VhdlParser::group_constituent_list() {QCString s,s1,s2;
4151     if (!hasError) {
4152     if (!hasError) {
4153     s1 = group_constituent();
4154     }
4155     }
4156     if (!hasError) {
4157     while (!hasError) {
4158       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4159       case COMMA_T:{
4160         ;
4161         break;
4162         }
4163       default:
4164         jj_la1[112] = jj_gen;
4165         goto end_label_21;
4166       }
4167       if (!hasError) {
4168       jj_consume_token(COMMA_T);
4169       }
4170       if (!hasError) {
4171       s = group_constituent();
4172       }
4173       if (!hasError) {
4174 s2+=",";s2+=s1;
4175       }
4176     }
4177     end_label_21: ;
4178     }
4179 return s+s2;
4180 assert(false);
4181 }
4182 
4183 
group_declaration()4184 QCString VhdlParser::group_declaration() {QCString s,s1,s2;
4185     if (!hasError) {
4186     jj_consume_token(GROUP_T);
4187     }
4188     if (!hasError) {
4189     s = identifier();
4190     }
4191     if (!hasError) {
4192     jj_consume_token(COLON_T);
4193     }
4194     if (!hasError) {
4195     s1 = identifier();
4196     }
4197     if (!hasError) {
4198     jj_consume_token(LPAREN_T);
4199     }
4200     if (!hasError) {
4201     s2 = group_constituent_list();
4202     }
4203     if (!hasError) {
4204     jj_consume_token(RPAREN_T);
4205     }
4206     if (!hasError) {
4207     jj_consume_token(SEMI_T);
4208     }
4209 return "group "+s+":"+s1+"("+s2+");";
4210 assert(false);
4211 }
4212 
4213 
group_template_declaration()4214 QCString VhdlParser::group_template_declaration() {QCString s,s1;
4215     if (!hasError) {
4216     jj_consume_token(GROUP_T);
4217     }
4218     if (!hasError) {
4219     s = identifier();
4220     }
4221     if (!hasError) {
4222     jj_consume_token(IS_T);
4223     }
4224     if (!hasError) {
4225     jj_consume_token(LPAREN_T);
4226     }
4227     if (!hasError) {
4228     s1 = entity_class_entry_list();
4229     }
4230     if (!hasError) {
4231     jj_consume_token(RPAREN_T);
4232     }
4233     if (!hasError) {
4234     jj_consume_token(SEMI_T);
4235     }
4236 return "group "+s+ "is ("+s1+");";
4237 assert(false);
4238 }
4239 
4240 
guarded_signal_specification()4241 void VhdlParser::guarded_signal_specification() {
4242     if (!hasError) {
4243     signal_list();
4244     }
4245     if (!hasError) {
4246     jj_consume_token(COLON_T);
4247     }
4248     if (!hasError) {
4249     type_mark();
4250     }
4251 }
4252 
4253 
identifier()4254 QCString VhdlParser::identifier() {Token *tok=0;
4255     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4256     case EXTENDED_CHARACTER:{
4257       if (!hasError) {
4258       tok = jj_consume_token(EXTENDED_CHARACTER);
4259       }
4260       if (!hasError) {
4261 return QCString(tok->image);
4262       }
4263       break;
4264       }
4265     case BASIC_IDENTIFIER:{
4266       if (!hasError) {
4267       tok = jj_consume_token(BASIC_IDENTIFIER);
4268       }
4269       if (!hasError) {
4270 return QCString(tok->image);
4271       }
4272       break;
4273       }
4274     default:
4275       jj_la1[113] = jj_gen;
4276       jj_consume_token(-1);
4277       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4278     }
4279 assert(false);
4280 }
4281 
4282 
identifier_list()4283 QCString VhdlParser::identifier_list() {QCString str,str1;
4284     if (!hasError) {
4285     str = name();
4286     }
4287     if (!hasError) {
4288     while (!hasError) {
4289       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4290       case COMMA_T:{
4291         ;
4292         break;
4293         }
4294       default:
4295         jj_la1[114] = jj_gen;
4296         goto end_label_22;
4297       }
4298       if (!hasError) {
4299       jj_consume_token(COMMA_T);
4300       }
4301       if (!hasError) {
4302       str1 = name();
4303       }
4304       if (!hasError) {
4305 str+=",";str+=str1;
4306       }
4307     }
4308     end_label_22: ;
4309     }
4310 return str;
4311 assert(false);
4312 }
4313 
4314 
if_statement()4315 void VhdlParser::if_statement() {QCString s,s1;
4316     if (!hasError) {
4317     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4318     case BASIC_IDENTIFIER:
4319     case EXTENDED_CHARACTER:{
4320       if (!hasError) {
4321       identifier();
4322       }
4323       if (!hasError) {
4324       jj_consume_token(COLON_T);
4325       }
4326       break;
4327       }
4328     default:
4329       jj_la1[115] = jj_gen;
4330       ;
4331     }
4332     }
4333     if (!hasError) {
4334     jj_consume_token(IF_T);
4335     }
4336     if (!hasError) {
4337     s = condition();
4338     }
4339     if (!hasError) {
4340     jj_consume_token(THEN_T);
4341     }
4342     if (!hasError) {
4343 s.prepend("if ");
4344       FlowChart::addFlowChart(FlowChart::IF_NO,QCString(),s);
4345     }
4346     if (!hasError) {
4347     sequence_of_statement();
4348     }
4349     if (!hasError) {
4350     while (!hasError) {
4351       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4352       case ELSIF_T:{
4353         ;
4354         break;
4355         }
4356       default:
4357         jj_la1[116] = jj_gen;
4358         goto end_label_23;
4359       }
4360       if (!hasError) {
4361       jj_consume_token(ELSIF_T);
4362       }
4363       if (!hasError) {
4364       s1 = condition();
4365       }
4366       if (!hasError) {
4367       jj_consume_token(THEN_T);
4368       }
4369       if (!hasError) {
4370 s1.prepend("elsif ");
4371      FlowChart::addFlowChart(FlowChart::ELSIF_NO,QCString(),s1);
4372       }
4373       if (!hasError) {
4374       sequence_of_statement();
4375       }
4376     }
4377     end_label_23: ;
4378     }
4379     if (!hasError) {
4380     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4381     case ELSE_T:{
4382       if (!hasError) {
4383       jj_consume_token(ELSE_T);
4384       }
4385       if (!hasError) {
4386 FlowChart::addFlowChart(FlowChart::ELSE_NO,QCString(),QCString());
4387       }
4388       if (!hasError) {
4389       sequence_of_statement();
4390       }
4391       break;
4392       }
4393     default:
4394       jj_la1[117] = jj_gen;
4395       ;
4396     }
4397     }
4398     if (!hasError) {
4399     jj_consume_token(END_T);
4400     }
4401     if (!hasError) {
4402     jj_consume_token(IF_T);
4403     }
4404     if (!hasError) {
4405     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4406     case BASIC_IDENTIFIER:
4407     case EXTENDED_CHARACTER:{
4408       if (!hasError) {
4409       identifier();
4410       }
4411       break;
4412       }
4413     default:
4414       jj_la1[118] = jj_gen;
4415       ;
4416     }
4417     }
4418     if (!hasError) {
4419     jj_consume_token(SEMI_T);
4420     }
4421 FlowChart::moveToPrevLevel();
4422     FlowChart::addFlowChart(FlowChart::ENDIF_NO,QCString(),QCString());
4423 }
4424 
4425 
incomplete_type_declaration()4426 QCString VhdlParser::incomplete_type_declaration() {QCString s;
4427     if (!hasError) {
4428     jj_consume_token(TYPE_T);
4429     }
4430     if (!hasError) {
4431     s = identifier();
4432     }
4433     if (!hasError) {
4434     jj_consume_token(SEMI_T);
4435     }
4436 return "type "+s+";";
4437 assert(false);
4438 }
4439 
4440 
index_constraint()4441 QCString VhdlParser::index_constraint() {QCString s("("); QCString s1,s2;
4442     if (!hasError) {
4443     jj_consume_token(LPAREN_T);
4444     }
4445     if (!hasError) {
4446     s2 = discrete_range();
4447     }
4448     if (!hasError) {
4449 s+=s2;
4450     }
4451     if (!hasError) {
4452     while (!hasError) {
4453       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4454       case COMMA_T:{
4455         ;
4456         break;
4457         }
4458       default:
4459         jj_la1[119] = jj_gen;
4460         goto end_label_24;
4461       }
4462       if (!hasError) {
4463       jj_consume_token(COMMA_T);
4464       }
4465       if (!hasError) {
4466       s1 = discrete_range();
4467       }
4468       if (!hasError) {
4469 s+=",";s+=s1;
4470       }
4471     }
4472     end_label_24: ;
4473     }
4474     if (!hasError) {
4475     jj_consume_token(RPAREN_T);
4476     }
4477 return s+")";
4478 assert(false);
4479 }
4480 
4481 
index_specification()4482 QCString VhdlParser::index_specification() {QCString s;
4483     if (jj_2_40(2147483647)) {
4484       if (!hasError) {
4485       s = discrete_range();
4486       }
4487       if (!hasError) {
4488 return s;
4489       }
4490     } else {
4491       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4492       case ABS_T:
4493       case AND_T:
4494       case NAND_T:
4495       case NEW_T:
4496       case NOR_T:
4497       case NOT_T:
4498       case NULL_T:
4499       case OR_T:
4500       case XOR_T:
4501       case XNOR_T:
4502       case LPAREN_T:
4503       case PLUS_T:
4504       case MINUS_T:
4505       case SLSL_T:
4506       case QQ_T:
4507       case INTEGER:
4508       case STRINGLITERAL:
4509       case BASIC_IDENTIFIER:
4510       case EXTENDED_CHARACTER:
4511       case CHARACTER_LITERAL:
4512       case DECIMAL_LITERAL:
4513       case BASED_LITERAL:
4514       case BIT_STRING_LITERAL:{
4515         if (!hasError) {
4516         s = expression();
4517         }
4518         if (!hasError) {
4519 return s;
4520         }
4521         break;
4522         }
4523       default:
4524         jj_la1[120] = jj_gen;
4525         jj_consume_token(-1);
4526         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4527       }
4528     }
4529 assert(false);
4530 }
4531 
4532 
index_subtype_definition()4533 QCString VhdlParser::index_subtype_definition() {QCString s;
4534     if (!hasError) {
4535     s = type_mark();
4536     }
4537     if (!hasError) {
4538     jj_consume_token(RANGE_T);
4539     }
4540     if (!hasError) {
4541     jj_consume_token(BOX_T);
4542     }
4543 return s+" range <> ";
4544 assert(false);
4545 }
4546 
4547 
instantiation_unit()4548 QCString VhdlParser::instantiation_unit() {QCString s,s1,s2;
4549     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4550     case COMPONENT_T:
4551     case BASIC_IDENTIFIER:
4552     case EXTENDED_CHARACTER:{
4553       if (!hasError) {
4554       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4555       case COMPONENT_T:{
4556         if (!hasError) {
4557         jj_consume_token(COMPONENT_T);
4558         }
4559         break;
4560         }
4561       default:
4562         jj_la1[121] = jj_gen;
4563         ;
4564       }
4565       }
4566       if (!hasError) {
4567       s = identifier();
4568       }
4569       if (!hasError) {
4570 s1="component "; return s;
4571       }
4572       break;
4573       }
4574     case ENTITY_T:{
4575       if (!hasError) {
4576       jj_consume_token(ENTITY_T);
4577       }
4578       if (!hasError) {
4579       if (jj_2_41(2)) {
4580         if (!hasError) {
4581         jj_consume_token(BASIC_IDENTIFIER);
4582         }
4583         if (!hasError) {
4584         jj_consume_token(DOT_T);
4585         }
4586       } else {
4587         ;
4588       }
4589       }
4590       if (!hasError) {
4591       s2 = name();
4592       }
4593       if (!hasError) {
4594 s="entity|"+s2;
4595       }
4596       if (!hasError) {
4597       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4598       case LPAREN_T:{
4599         if (!hasError) {
4600         jj_consume_token(LPAREN_T);
4601         }
4602         if (!hasError) {
4603         s1 = identifier();
4604         }
4605         if (!hasError) {
4606         jj_consume_token(RPAREN_T);
4607         }
4608         if (!hasError) {
4609 s+="(";s+=s1;s+=")" ;
4610         }
4611         break;
4612         }
4613       default:
4614         jj_la1[122] = jj_gen;
4615         ;
4616       }
4617       }
4618       if (!hasError) {
4619 return s;
4620       }
4621       break;
4622       }
4623     case CONFIGURATION_T:{
4624       if (!hasError) {
4625       jj_consume_token(CONFIGURATION_T);
4626       }
4627       if (!hasError) {
4628       s = name();
4629       }
4630       if (!hasError) {
4631 s1="configuration ";return s;
4632       }
4633       break;
4634       }
4635     default:
4636       jj_la1[123] = jj_gen;
4637       jj_consume_token(-1);
4638       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4639     }
4640 assert(false);
4641 }
4642 
4643 
instantiation_list()4644 QCString VhdlParser::instantiation_list() {QCString s;Token *tok=0;
4645     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4646     case SLSL_T:
4647     case STRINGLITERAL:
4648     case BASIC_IDENTIFIER:
4649     case EXTENDED_CHARACTER:{
4650       if (!hasError) {
4651       s = identifier_list();
4652       }
4653       if (!hasError) {
4654 return s;
4655       }
4656       break;
4657       }
4658     case OTHER_T:{
4659       if (!hasError) {
4660       tok = jj_consume_token(OTHER_T);
4661       }
4662       if (!hasError) {
4663 return QCString(tok->image);
4664       }
4665       break;
4666       }
4667     case ALL_T:{
4668       if (!hasError) {
4669       tok = jj_consume_token(ALL_T);
4670       }
4671       if (!hasError) {
4672 return QCString(tok->image);
4673       }
4674       break;
4675       }
4676     default:
4677       jj_la1[124] = jj_gen;
4678       jj_consume_token(-1);
4679       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4680     }
4681 assert(false);
4682 }
4683 
4684 
integer()4685 QCString VhdlParser::integer() {Token *t;
4686     if (!hasError) {
4687     t = jj_consume_token(INTEGER);
4688     }
4689 return QCString(t->image);
4690 assert(false);
4691 }
4692 
4693 
integer_type_definition()4694 QCString VhdlParser::integer_type_definition() {QCString s;
4695     if (!hasError) {
4696     s = range_constraint();
4697     }
4698 return s;
4699 assert(false);
4700 }
4701 
4702 
interface_declaration()4703 QCString VhdlParser::interface_declaration() {QCString s,s1;
4704     if (jj_2_42(5)) {
4705       if (!hasError) {
4706       s = interface_subprogram_declaration();
4707       }
4708       if (!hasError) {
4709 return s;
4710       }
4711     } else if (jj_2_43(5)) {
4712       if (!hasError) {
4713       interface_package_declaration();
4714       }
4715       if (!hasError) {
4716 return s;
4717       }
4718     } else if (jj_2_44(5)) {
4719       if (!hasError) {
4720       s = interface_variable_declaration();
4721       }
4722       if (!hasError) {
4723 return s;
4724       }
4725     } else if (jj_2_45(5)) {
4726       if (!hasError) {
4727       interface_file_declaration();
4728       }
4729       if (!hasError) {
4730 return s;
4731       }
4732     } else if (jj_2_46(2147483647)) {
4733       if (!hasError) {
4734       subprogram_declaration();
4735       }
4736       if (!hasError) {
4737 return s;
4738       }
4739     } else {
4740       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4741       case CONSTANT_T:
4742       case FILE_T:
4743       case SIGNAL_T:
4744       case SHARED_T:
4745       case TYPE_T:
4746       case VARIABLE_T:{
4747         if (!hasError) {
4748         s = object_class();
4749         }
4750         if (!hasError) {
4751         s1 = identifier();
4752         }
4753         if (!hasError) {
4754 if (m_sharedState->parse_sec==GEN_SEC)
4755      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,s1.data(),0,Public);
4756    return s;
4757         }
4758         break;
4759         }
4760       default:
4761         jj_la1[125] = jj_gen;
4762         jj_consume_token(-1);
4763         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4764       }
4765     }
4766 assert(false);
4767 }
4768 
4769 
interface_element()4770 QCString VhdlParser::interface_element() {QCString s;
4771     if (!hasError) {
4772     s = interface_declaration();
4773     }
4774 return s;
4775 assert(false);
4776 }
4777 
4778 
interface_file_declaration()4779 QCString VhdlParser::interface_file_declaration() {QCString s,s1;
4780     if (!hasError) {
4781     jj_consume_token(FILE_T);
4782     }
4783     if (!hasError) {
4784     s = identifier_list();
4785     }
4786     if (!hasError) {
4787     jj_consume_token(COLON_T);
4788     }
4789     if (!hasError) {
4790     s1 = subtype_indication();
4791     }
4792 outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
4793     return QCString(" file "+s+":"+s1);
4794 assert(false);
4795 }
4796 
4797 
interface_list()4798 QCString VhdlParser::interface_list() {QCString s,s1,s2;
4799     if (!hasError) {
4800     s = interface_element();
4801     }
4802     if (!hasError) {
4803     while (!hasError) {
4804       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4805       case SEMI_T:{
4806         ;
4807         break;
4808         }
4809       default:
4810         jj_la1[126] = jj_gen;
4811         goto end_label_25;
4812       }
4813       if (!hasError) {
4814       jj_consume_token(SEMI_T);
4815       }
4816       if (!hasError) {
4817       s1 = interface_element();
4818       }
4819       if (!hasError) {
4820 s2+=";";s2+=s1;
4821       }
4822     }
4823     end_label_25: ;
4824     }
4825 return s+s2;
4826 assert(false);
4827 }
4828 
4829 
interface_variable_declaration()4830 QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;
4831     if (!hasError) {
4832     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4833     case CONSTANT_T:
4834     case SIGNAL_T:
4835     case SHARED_T:
4836     case VARIABLE_T:{
4837       if (!hasError) {
4838       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4839       case VARIABLE_T:{
4840         if (!hasError) {
4841         tok = jj_consume_token(VARIABLE_T);
4842         }
4843         break;
4844         }
4845       case SIGNAL_T:{
4846         if (!hasError) {
4847         tok = jj_consume_token(SIGNAL_T);
4848         }
4849         break;
4850         }
4851       case CONSTANT_T:{
4852         if (!hasError) {
4853         tok = jj_consume_token(CONSTANT_T);
4854         }
4855         break;
4856         }
4857       case SHARED_T:{
4858         if (!hasError) {
4859         tok = jj_consume_token(SHARED_T);
4860         }
4861         break;
4862         }
4863       default:
4864         jj_la1[127] = jj_gen;
4865         jj_consume_token(-1);
4866         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4867       }
4868       }
4869       break;
4870       }
4871     default:
4872       jj_la1[128] = jj_gen;
4873       ;
4874     }
4875     }
4876     if (!hasError) {
4877     s = identifier_list();
4878     }
4879     if (!hasError) {
4880     jj_consume_token(COLON_T);
4881     }
4882     if (!hasError) {
4883     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4884     case BUFFER_T:
4885     case IN_T:
4886     case INOUT_T:
4887     case LINKAGE_T:
4888     case OUT_T:{
4889       if (!hasError) {
4890       s1 = mode();
4891       }
4892       break;
4893       }
4894     default:
4895       jj_la1[129] = jj_gen;
4896       ;
4897     }
4898     }
4899     if (!hasError) {
4900     s2 = subtype_indication();
4901     }
4902     if (!hasError) {
4903     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4904     case BUS_T:{
4905       if (!hasError) {
4906       tok1 = jj_consume_token(BUS_T);
4907       }
4908       break;
4909       }
4910     default:
4911       jj_la1[130] = jj_gen;
4912       ;
4913     }
4914     }
4915     if (!hasError) {
4916     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4917     case VARASSIGN_T:{
4918       if (!hasError) {
4919       tok2 = jj_consume_token(VARASSIGN_T);
4920       }
4921       if (!hasError) {
4922       s4 = expression();
4923       }
4924       break;
4925       }
4926     default:
4927       jj_la1[131] = jj_gen;
4928       ;
4929     }
4930     }
4931 if(tok)
4932         s5=QCString(tok->image);
4933 
4934       if(tok1)
4935         s3=tok1->image.data();
4936 
4937       if(tok2)
4938         s3+=":=";
4939 
4940       QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
4941       if (m_sharedState->currP!=VhdlDocGen::COMPONENT)
4942       {
4943         if (m_sharedState->currP==VhdlDocGen::FUNCTION || m_sharedState->currP==VhdlDocGen::PROCEDURE)
4944         {
4945           outlineParser()->addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
4946         }
4947         else
4948         {
4949           QCString i=s2+s3+s4;
4950           if (m_sharedState->currP==VhdlDocGen::GENERIC && m_sharedState->param_sec==0)
4951             outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
4952           else if(m_sharedState->parse_sec != GEN_SEC)
4953             outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,m_sharedState->currP,i.data(),s1.data(),Public);
4954         }
4955         //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
4956       } // if component
4957       return it;
4958 assert(false);
4959 }
4960 
4961 
iteration_scheme()4962 QCString VhdlParser::iteration_scheme() {QCString s;
4963     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
4964     case WHILE_T:{
4965       if (!hasError) {
4966       jj_consume_token(WHILE_T);
4967       }
4968       if (!hasError) {
4969       s = condition();
4970       }
4971       if (!hasError) {
4972 s.prepend("while ");
4973    FlowChart::addFlowChart(FlowChart::WHILE_NO,QCString(),s,m_sharedState->lab);
4974    m_sharedState->lab="";
4975   return s;
4976       }
4977       break;
4978       }
4979     case FOR_T:{
4980       if (!hasError) {
4981       jj_consume_token(FOR_T);
4982       }
4983       if (!hasError) {
4984       s = parameter_specification();
4985       }
4986       if (!hasError) {
4987 QCString q=m_sharedState->lab+" for "+s;
4988     FlowChart::addFlowChart(FlowChart::FOR_NO,QCString(),q,m_sharedState->lab);
4989     m_sharedState->lab="";
4990     return q;
4991       }
4992       break;
4993       }
4994     default:
4995       jj_la1[132] = jj_gen;
4996       jj_consume_token(-1);
4997       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
4998     }
4999 assert(false);
5000 }
5001 
5002 
label()5003 QCString VhdlParser::label() {QCString s;
5004     if (!hasError) {
5005     s = identifier();
5006     }
5007 return s;
5008 assert(false);
5009 }
5010 
5011 
library_clause()5012 QCString VhdlParser::library_clause() {QCString s;
5013     if (!hasError) {
5014     if (!hasError) {
5015     jj_consume_token(LIBRARY_T);
5016     }
5017     if (!hasError) {
5018     s = identifier_list();
5019     }
5020     if (!hasError) {
5021     jj_consume_token(SEMI_T);
5022     }
5023     }
5024 if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
5025                    {
5026                            outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
5027                    }
5028                    QCString s1="library "+s;
5029                    return s1;
5030 assert(false);
5031 }
5032 
5033 
library_unit()5034 QCString VhdlParser::library_unit() {QCString s;
5035     if (jj_2_47(2)) {
5036       if (!hasError) {
5037       primary_unit();
5038       }
5039       if (!hasError) {
5040 return s;
5041       }
5042     } else {
5043       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5044       case ARCHITECTURE_T:
5045       case PACKAGE_T:{
5046         if (!hasError) {
5047         secondary_unit();
5048         }
5049         if (!hasError) {
5050 return s;
5051         }
5052         break;
5053         }
5054       default:
5055         jj_la1[133] = jj_gen;
5056         jj_consume_token(-1);
5057         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5058       }
5059     }
5060 assert(false);
5061 }
5062 
5063 
literal()5064 QCString VhdlParser::literal() {QCString s;
5065     if (jj_2_48(2147483647)) {
5066       if (!hasError) {
5067       s = bit_string_literal();
5068       }
5069       if (!hasError) {
5070 return s;
5071       }
5072     } else if (jj_2_49(2147483647)) {
5073       if (!hasError) {
5074       s = numeric_literal();
5075       }
5076       if (!hasError) {
5077 return s;
5078       }
5079     } else if (jj_2_50(2147483647)) {
5080       if (!hasError) {
5081       s = enumeration_literal();
5082       }
5083       if (!hasError) {
5084 return s;
5085       }
5086     } else {
5087       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5088       case STRINGLITERAL:{
5089         if (!hasError) {
5090         s = string_literal();
5091         }
5092         if (!hasError) {
5093 return s;
5094         }
5095         break;
5096         }
5097       case NULL_T:{
5098         if (!hasError) {
5099         jj_consume_token(NULL_T);
5100         }
5101         if (!hasError) {
5102 return "null";
5103         }
5104         break;
5105         }
5106       default:
5107         jj_la1[134] = jj_gen;
5108         jj_consume_token(-1);
5109         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5110       }
5111     }
5112 assert(false);
5113 }
5114 
5115 
logical_operator()5116 QCString VhdlParser::logical_operator() {QCString s;
5117     if (!hasError) {
5118     s = logop();
5119     }
5120 return s;
5121 assert(false);
5122 }
5123 
5124 
loop_statement()5125 QCString VhdlParser::loop_statement() {QCString s,s1,s2,s3;
5126     if (!hasError) {
5127     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5128     case BASIC_IDENTIFIER:
5129     case EXTENDED_CHARACTER:{
5130       if (!hasError) {
5131       s = identifier();
5132       }
5133       if (!hasError) {
5134       jj_consume_token(COLON_T);
5135       }
5136       if (!hasError) {
5137 s+=":";
5138       }
5139       break;
5140       }
5141     default:
5142       jj_la1[135] = jj_gen;
5143       ;
5144     }
5145     }
5146     if (!hasError) {
5147     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5148     case FOR_T:
5149     case WHILE_T:{
5150       if (!hasError) {
5151       s1 = iteration_scheme();
5152       }
5153       break;
5154       }
5155     default:
5156       jj_la1[136] = jj_gen;
5157       ;
5158     }
5159     }
5160     if (!hasError) {
5161 if(s1.isEmpty())
5162         FlowChart::addFlowChart(FlowChart::LOOP_NO,QCString(),"infinite");
5163     }
5164     if (!hasError) {
5165     jj_consume_token(LOOP_T);
5166     }
5167     if (!hasError) {
5168     s2 = sequence_of_statement();
5169     }
5170     if (!hasError) {
5171     jj_consume_token(END_T);
5172     }
5173     if (!hasError) {
5174     jj_consume_token(LOOP_T);
5175     }
5176     if (!hasError) {
5177     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5178     case BASIC_IDENTIFIER:
5179     case EXTENDED_CHARACTER:{
5180       if (!hasError) {
5181       s3 = identifier();
5182       }
5183       break;
5184       }
5185     default:
5186       jj_la1[137] = jj_gen;
5187       ;
5188     }
5189     }
5190     if (!hasError) {
5191     jj_consume_token(SEMI_T);
5192     }
5193 QCString q = s+" loop "+s2+" end loop" +s3;
5194          QCString endLoop="end loop" + s3;
5195          FlowChart::moveToPrevLevel();
5196          FlowChart::addFlowChart(FlowChart::END_LOOP,endLoop,QCString());
5197         return q;
5198 assert(false);
5199 }
5200 
5201 
miscellaneous_operator()5202 QCString VhdlParser::miscellaneous_operator() {Token *t=0;
5203     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5204     case DOUBLEMULT_T:{
5205       if (!hasError) {
5206       jj_consume_token(DOUBLEMULT_T);
5207       }
5208       if (!hasError) {
5209 return "**";
5210       }
5211       break;
5212       }
5213     case ABS_T:{
5214       if (!hasError) {
5215       jj_consume_token(ABS_T);
5216       }
5217       if (!hasError) {
5218 return "abs";
5219       }
5220       break;
5221       }
5222     case NOT_T:{
5223       if (!hasError) {
5224       jj_consume_token(NOT_T);
5225       }
5226       if (!hasError) {
5227 return "not";
5228       }
5229       break;
5230       }
5231     default:
5232       jj_la1[138] = jj_gen;
5233       jj_consume_token(-1);
5234       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5235     }
5236 assert(false);
5237 }
5238 
5239 
mode()5240 QCString VhdlParser::mode() {Token *tok=0;
5241     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5242     case IN_T:{
5243       if (!hasError) {
5244       tok = jj_consume_token(IN_T);
5245       }
5246       if (!hasError) {
5247 return "in";
5248       }
5249       break;
5250       }
5251     case OUT_T:{
5252       if (!hasError) {
5253       tok = jj_consume_token(OUT_T);
5254       }
5255       if (!hasError) {
5256 return "out";
5257       }
5258       break;
5259       }
5260     case INOUT_T:{
5261       if (!hasError) {
5262       tok = jj_consume_token(INOUT_T);
5263       }
5264       if (!hasError) {
5265 return "inout";
5266       }
5267       break;
5268       }
5269     case BUFFER_T:{
5270       if (!hasError) {
5271       tok = jj_consume_token(BUFFER_T);
5272       }
5273       if (!hasError) {
5274 return "buffer";
5275       }
5276       break;
5277       }
5278     case LINKAGE_T:{
5279       if (!hasError) {
5280       tok = jj_consume_token(LINKAGE_T);
5281       }
5282       if (!hasError) {
5283 return "linkage";
5284       }
5285       break;
5286       }
5287     default:
5288       jj_la1[139] = jj_gen;
5289       jj_consume_token(-1);
5290       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5291     }
5292 assert(false);
5293 }
5294 
5295 
multiplying_operation()5296 QCString VhdlParser::multiplying_operation() {Token *tok=0;
5297     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5298     case MULT_T:{
5299       if (!hasError) {
5300       tok = jj_consume_token(MULT_T);
5301       }
5302       if (!hasError) {
5303 return QCString(tok->image);
5304       }
5305       break;
5306       }
5307     case SLASH_T:{
5308       if (!hasError) {
5309       tok = jj_consume_token(SLASH_T);
5310       }
5311       if (!hasError) {
5312 return QCString(tok->image);
5313       }
5314       break;
5315       }
5316     case MOD_T:{
5317       if (!hasError) {
5318       tok = jj_consume_token(MOD_T);
5319       }
5320       if (!hasError) {
5321 return QCString(tok->image);
5322       }
5323       break;
5324       }
5325     case REM_T:{
5326       if (!hasError) {
5327       tok = jj_consume_token(REM_T);
5328       }
5329       if (!hasError) {
5330 return QCString(tok->image);
5331       }
5332       break;
5333       }
5334     default:
5335       jj_la1[140] = jj_gen;
5336       jj_consume_token(-1);
5337       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5338     }
5339 assert(false);
5340 }
5341 
5342 
name()5343 QCString VhdlParser::name() {QCString s,s1;
5344     if (!hasError) {
5345     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5346     case STRINGLITERAL:{
5347       if (!hasError) {
5348       s = operator_symbol();
5349       }
5350       if (!hasError) {
5351       if (jj_2_51(2147483647)) {
5352         if (!hasError) {
5353         s1 = name_ext1();
5354         }
5355         if (!hasError) {
5356 s+=s1;
5357         }
5358       } else {
5359         ;
5360       }
5361       }
5362       if (!hasError) {
5363 return s;
5364       }
5365       break;
5366       }
5367     case SLSL_T:{
5368       if (!hasError) {
5369       s = external_name();
5370       }
5371       if (!hasError) {
5372       if (jj_2_52(2147483647)) {
5373         if (!hasError) {
5374         s1 = name_ext1();
5375         }
5376         if (!hasError) {
5377 s+=s1;
5378         }
5379       } else {
5380         ;
5381       }
5382       }
5383       if (!hasError) {
5384 return s;
5385       }
5386       break;
5387       }
5388     case BASIC_IDENTIFIER:
5389     case EXTENDED_CHARACTER:{
5390       if (!hasError) {
5391       s = identifier();
5392       }
5393       if (!hasError) {
5394       if (jj_2_53(2147483647)) {
5395         if (!hasError) {
5396         s1 = name_ext1();
5397         }
5398         if (!hasError) {
5399 s+=s1;
5400         }
5401       } else {
5402         ;
5403       }
5404       }
5405       if (!hasError) {
5406 return s;
5407       }
5408       break;
5409       }
5410     default:
5411       jj_la1[141] = jj_gen;
5412       jj_consume_token(-1);
5413       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5414     }
5415     }
5416 assert(false);
5417 }
5418 
5419 
name_ext1()5420 QCString VhdlParser::name_ext1() {QCString s,s1,s2;
5421     if (!hasError) {
5422     s = name_ext();
5423     }
5424     if (!hasError) {
5425     while (!hasError) {
5426       if (jj_2_54(2147483647)) {
5427         ;
5428       } else {
5429         goto end_label_26;
5430       }
5431       if (!hasError) {
5432       s1 = name_ext();
5433       }
5434       if (!hasError) {
5435 s+=s1;
5436       }
5437     }
5438     end_label_26: ;
5439     }
5440 return s;
5441 assert(false);
5442 }
5443 
5444 
name_ext()5445 QCString VhdlParser::name_ext() {QCString s,s1,s2;
5446     if (!hasError) {
5447     if (jj_2_55(2147483647)) {
5448       if (!hasError) {
5449       jj_consume_token(APOSTROPHE_T);
5450       }
5451       if (!hasError) {
5452       jj_consume_token(SUBTYPE_T);
5453       }
5454       if (!hasError) {
5455 s+="'subtype"; return s;
5456       }
5457     } else if (jj_2_56(2147483647)) {
5458       if (!hasError) {
5459       jj_consume_token(DOT_T);
5460       }
5461       if (!hasError) {
5462       s1 = suffix();
5463       }
5464       if (!hasError) {
5465 s+=".";s+=s1; return s;
5466       }
5467     } else if (jj_2_57(2147483647)) {
5468       if (!hasError) {
5469       s1 = test_att_name();
5470       }
5471       if (!hasError) {
5472 s+=s1;return s;
5473       }
5474     } else if (jj_2_58(2147483647)) {
5475       if (!hasError) {
5476       jj_consume_token(LPAREN_T);
5477       }
5478       if (!hasError) {
5479       s1 = discrete_range();
5480       }
5481       if (!hasError) {
5482       jj_consume_token(RPAREN_T);
5483       }
5484       if (!hasError) {
5485 s+="(";s+=s1;s+=")";return s;
5486       }
5487     } else if (jj_2_59(2147483647)) {
5488       if (!hasError) {
5489       jj_consume_token(LPAREN_T);
5490       }
5491       if (!hasError) {
5492       s1 = expression();
5493       }
5494       if (!hasError) {
5495 s+="(";s+=s1;
5496       }
5497       if (!hasError) {
5498       while (!hasError) {
5499         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5500         case COMMA_T:{
5501           ;
5502           break;
5503           }
5504         default:
5505           jj_la1[142] = jj_gen;
5506           goto end_label_27;
5507         }
5508         if (!hasError) {
5509         jj_consume_token(COMMA_T);
5510         }
5511         if (!hasError) {
5512         s1 = expression();
5513         }
5514         if (!hasError) {
5515 s+=",";s+=s1;
5516         }
5517       }
5518       end_label_27: ;
5519       }
5520       if (!hasError) {
5521       jj_consume_token(RPAREN_T);
5522       }
5523       if (!hasError) {
5524 s+=")";return s;
5525       }
5526     } else {
5527       jj_consume_token(-1);
5528       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5529     }
5530     }
5531 assert(false);
5532 }
5533 
5534 
test_att_name()5535 QCString VhdlParser::test_att_name() {QCString s,s1;
5536     if (!hasError) {
5537     if (jj_2_60(2147483647)) {
5538       if (!hasError) {
5539       s1 = signature();
5540       }
5541       if (!hasError) {
5542 s=s1;
5543       }
5544     } else {
5545       ;
5546     }
5547     }
5548     if (!hasError) {
5549     jj_consume_token(APOSTROPHE_T);
5550     }
5551     if (!hasError) {
5552     s1 = attribute_designator();
5553     }
5554     if (!hasError) {
5555 s+="'";s+=s1;
5556     }
5557     if (!hasError) {
5558     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5559     case LPAREN_T:{
5560       if (!hasError) {
5561       jj_consume_token(LPAREN_T);
5562       }
5563       if (!hasError) {
5564       s1 = expression();
5565       }
5566       if (!hasError) {
5567       jj_consume_token(RPAREN_T);
5568       }
5569       if (!hasError) {
5570 s+="(";s+=s1;s+=")";
5571       }
5572       break;
5573       }
5574     default:
5575       jj_la1[143] = jj_gen;
5576       ;
5577     }
5578     }
5579 return s;
5580 assert(false);
5581 }
5582 
5583 
indexed_name()5584 QCString VhdlParser::indexed_name() {QCString s,s1,s2;
5585     if (!hasError) {
5586     s2 = identifier();
5587     }
5588     if (!hasError) {
5589     jj_consume_token(LPAREN_T);
5590     }
5591     if (!hasError) {
5592     s1 = expression();
5593     }
5594     if (!hasError) {
5595 s=s2+"("+s1;
5596     }
5597     if (!hasError) {
5598     while (!hasError) {
5599       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5600       case COMMA_T:{
5601         ;
5602         break;
5603         }
5604       default:
5605         jj_la1[144] = jj_gen;
5606         goto end_label_28;
5607       }
5608       if (!hasError) {
5609       jj_consume_token(COMMA_T);
5610       }
5611       if (!hasError) {
5612       s1 = expression();
5613       }
5614       if (!hasError) {
5615 s+=",";s+=s1;
5616       }
5617     }
5618     end_label_28: ;
5619     }
5620     if (!hasError) {
5621     jj_consume_token(RPAREN_T);
5622     }
5623 return s+")";
5624 assert(false);
5625 }
5626 
5627 
next_statement()5628 QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
5629     if (!hasError) {
5630     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5631     case BASIC_IDENTIFIER:
5632     case EXTENDED_CHARACTER:{
5633       if (!hasError) {
5634       s = identifier();
5635       }
5636       if (!hasError) {
5637       t = jj_consume_token(COLON_T);
5638       }
5639       break;
5640       }
5641     default:
5642       jj_la1[145] = jj_gen;
5643       ;
5644     }
5645     }
5646     if (!hasError) {
5647     jj_consume_token(NEXT_T);
5648     }
5649     if (!hasError) {
5650     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5651     case BASIC_IDENTIFIER:
5652     case EXTENDED_CHARACTER:{
5653       if (!hasError) {
5654       s1 = identifier();
5655       }
5656       break;
5657       }
5658     default:
5659       jj_la1[146] = jj_gen;
5660       ;
5661     }
5662     }
5663     if (!hasError) {
5664     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5665     case WHEN_T:{
5666       if (!hasError) {
5667       t1 = jj_consume_token(WHEN_T);
5668       }
5669       if (!hasError) {
5670       s2 = condition();
5671       }
5672       break;
5673       }
5674     default:
5675       jj_la1[147] = jj_gen;
5676       ;
5677     }
5678     }
5679     if (!hasError) {
5680     jj_consume_token(SEMI_T);
5681     }
5682 if(t) s+=":";
5683    FlowChart::addFlowChart(FlowChart::NEXT_NO,"next ",s2,s1);
5684     m_sharedState->lab.resize(0);
5685   if(t1) s2.prepend("when ");
5686   return s+s1+s2+";";
5687 assert(false);
5688 }
5689 
5690 
null_statement()5691 QCString VhdlParser::null_statement() {QCString s;
5692     if (!hasError) {
5693     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5694     case BASIC_IDENTIFIER:
5695     case EXTENDED_CHARACTER:{
5696       if (!hasError) {
5697       s = identifier();
5698       }
5699       if (!hasError) {
5700       jj_consume_token(COLON_T);
5701       }
5702       if (!hasError) {
5703 s+=":";
5704       }
5705       break;
5706       }
5707     default:
5708       jj_la1[148] = jj_gen;
5709       ;
5710     }
5711     }
5712     if (!hasError) {
5713     jj_consume_token(NULL_T);
5714     }
5715     if (!hasError) {
5716     jj_consume_token(SEMI_T);
5717     }
5718 return s+="null";
5719 assert(false);
5720 }
5721 
5722 
numeric_literal()5723 QCString VhdlParser::numeric_literal() {QCString s;
5724     if (jj_2_61(2147483647)) {
5725       if (!hasError) {
5726       s = physical_literal();
5727       }
5728       if (!hasError) {
5729 return s;
5730       }
5731     } else {
5732       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5733       case INTEGER:
5734       case DECIMAL_LITERAL:
5735       case BASED_LITERAL:{
5736         if (!hasError) {
5737         s = abstract_literal();
5738         }
5739         if (!hasError) {
5740 return s;
5741         }
5742         break;
5743         }
5744       default:
5745         jj_la1[149] = jj_gen;
5746         jj_consume_token(-1);
5747         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5748       }
5749     }
5750 assert(false);
5751 }
5752 
5753 
object_class()5754 QCString VhdlParser::object_class() {
5755     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5756     case CONSTANT_T:{
5757       if (!hasError) {
5758       jj_consume_token(CONSTANT_T);
5759       }
5760       if (!hasError) {
5761 return "constant";
5762       }
5763       break;
5764       }
5765     case SIGNAL_T:{
5766       if (!hasError) {
5767       jj_consume_token(SIGNAL_T);
5768       }
5769       if (!hasError) {
5770 return "signal";
5771       }
5772       break;
5773       }
5774     case VARIABLE_T:{
5775       if (!hasError) {
5776       jj_consume_token(VARIABLE_T);
5777       }
5778       if (!hasError) {
5779 return "variable";
5780       }
5781       break;
5782       }
5783     case SHARED_T:{
5784       if (!hasError) {
5785       jj_consume_token(SHARED_T);
5786       }
5787       if (!hasError) {
5788       jj_consume_token(VARIABLE_T);
5789       }
5790       if (!hasError) {
5791 return "shared variable";
5792       }
5793       break;
5794       }
5795     case FILE_T:{
5796       if (!hasError) {
5797       jj_consume_token(FILE_T);
5798       }
5799       if (!hasError) {
5800 return "file";
5801       }
5802       break;
5803       }
5804     case TYPE_T:{
5805       if (!hasError) {
5806       jj_consume_token(TYPE_T);
5807       }
5808       if (!hasError) {
5809 return "type";
5810       }
5811       break;
5812       }
5813     default:
5814       jj_la1[150] = jj_gen;
5815       jj_consume_token(-1);
5816       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5817     }
5818 assert(false);
5819 }
5820 
5821 
operator_symbol()5822 QCString VhdlParser::operator_symbol() {Token *tok=0;
5823     if (!hasError) {
5824     tok = jj_consume_token(STRINGLITERAL);
5825     }
5826 return QCString(tok->image);
5827 assert(false);
5828 }
5829 
5830 
options()5831 void VhdlParser::options() {
5832     if (!hasError) {
5833     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5834     case GUARDED_T:{
5835       if (!hasError) {
5836       jj_consume_token(GUARDED_T);
5837       }
5838       break;
5839       }
5840     default:
5841       jj_la1[151] = jj_gen;
5842       ;
5843     }
5844     }
5845     if (!hasError) {
5846     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5847     case INERTIAL_T:
5848     case REJECT_T:
5849     case TRANSPORT_T:{
5850       if (!hasError) {
5851       delay_mechanism();
5852       }
5853       break;
5854       }
5855     default:
5856       jj_la1[152] = jj_gen;
5857       ;
5858     }
5859     }
5860 }
5861 
5862 
package_body()5863 void VhdlParser::package_body() {QCString s;
5864     if (!hasError) {
5865     jj_consume_token(PACKAGE_T);
5866     }
5867     if (!hasError) {
5868     jj_consume_token(BODY_T);
5869     }
5870     if (!hasError) {
5871     s = name();
5872     }
5873     if (!hasError) {
5874     jj_consume_token(IS_T);
5875     }
5876     if (!hasError) {
5877 m_sharedState->lastCompound=m_sharedState->current;
5878                         s.prepend("_");
5879                         outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
5880     }
5881     if (!hasError) {
5882     package_body_declarative_part();
5883     }
5884     if (!hasError) {
5885     jj_consume_token(END_T);
5886     }
5887     if (!hasError) {
5888     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5889     case PACKAGE_T:{
5890       if (!hasError) {
5891       jj_consume_token(PACKAGE_T);
5892       }
5893       if (!hasError) {
5894       jj_consume_token(BODY_T);
5895       }
5896       break;
5897       }
5898     default:
5899       jj_la1[153] = jj_gen;
5900       ;
5901     }
5902     }
5903     if (!hasError) {
5904     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5905     case SLSL_T:
5906     case STRINGLITERAL:
5907     case BASIC_IDENTIFIER:
5908     case EXTENDED_CHARACTER:{
5909       if (!hasError) {
5910       name();
5911       }
5912       break;
5913       }
5914     default:
5915       jj_la1[154] = jj_gen;
5916       ;
5917     }
5918     }
5919     if (!hasError) {
5920     jj_consume_token(SEMI_T);
5921     }
5922 m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
5923 }
5924 
5925 
package_body_declarative_item()5926 void VhdlParser::package_body_declarative_item() {
5927     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5928     case FUNCTION_T:
5929     case IMPURE_T:
5930     case PROCEDURE_T:
5931     case PURE_T:{
5932       if (!hasError) {
5933       subprogram_declaration();
5934       }
5935       break;
5936       }
5937     case TYPE_T:{
5938       if (!hasError) {
5939       type_declaration();
5940       }
5941       break;
5942       }
5943     case SUBTYPE_T:{
5944       if (!hasError) {
5945       subtype_declaration();
5946       }
5947       break;
5948       }
5949     case CONSTANT_T:{
5950       if (!hasError) {
5951       constant_declaration();
5952       }
5953       break;
5954       }
5955     case SHARED_T:
5956     case VARIABLE_T:{
5957       if (!hasError) {
5958       variable_declaration();
5959       }
5960       break;
5961       }
5962     case FILE_T:{
5963       if (!hasError) {
5964       file_declaration();
5965       }
5966       break;
5967       }
5968     case ALIAS_T:{
5969       if (!hasError) {
5970       alias_declaration();
5971       }
5972       break;
5973       }
5974     case USE_T:{
5975       if (!hasError) {
5976       use_clause();
5977       }
5978       break;
5979       }
5980     default:
5981       jj_la1[155] = jj_gen;
5982       if (jj_2_62(3)) {
5983         if (!hasError) {
5984         group_template_declaration();
5985         }
5986       } else {
5987         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
5988         case GROUP_T:{
5989           if (!hasError) {
5990           group_declaration();
5991           }
5992           break;
5993           }
5994         default:
5995           jj_la1[156] = jj_gen;
5996           jj_consume_token(-1);
5997           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
5998         }
5999       }
6000     }
6001 }
6002 
6003 
package_body_declarative_part()6004 void VhdlParser::package_body_declarative_part() {
6005     if (!hasError) {
6006     while (!hasError) {
6007       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6008       case ALIAS_T:
6009       case CONSTANT_T:
6010       case FILE_T:
6011       case FUNCTION_T:
6012       case GROUP_T:
6013       case IMPURE_T:
6014       case PROCEDURE_T:
6015       case PURE_T:
6016       case SHARED_T:
6017       case SUBTYPE_T:
6018       case TYPE_T:
6019       case USE_T:
6020       case VARIABLE_T:{
6021         ;
6022         break;
6023         }
6024       default:
6025         jj_la1[157] = jj_gen;
6026         goto end_label_29;
6027       }
6028       if (!hasError) {
6029       package_body_declarative_item();
6030       }
6031     }
6032     end_label_29: ;
6033     }
6034 }
6035 
6036 
package_header()6037 void VhdlParser::package_header() {QCString s;
6038     if (!hasError) {
6039     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6040     case GENERIC_T:{
6041       if (!hasError) {
6042       generic_clause();
6043       }
6044       if (!hasError) {
6045       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6046       case GENERIC_T:{
6047         if (!hasError) {
6048         generic_map_aspect();
6049         }
6050         if (!hasError) {
6051         jj_consume_token(SEMI_T);
6052         }
6053         break;
6054         }
6055       default:
6056         jj_la1[158] = jj_gen;
6057         ;
6058       }
6059       }
6060       break;
6061       }
6062     default:
6063       jj_la1[159] = jj_gen;
6064       ;
6065     }
6066     }
6067 }
6068 
6069 
package_declaration()6070 void VhdlParser::package_declaration() {QCString s;
6071     if (!hasError) {
6072     jj_consume_token(PACKAGE_T);
6073     }
6074     if (!hasError) {
6075     s = identifier();
6076     }
6077     if (!hasError) {
6078     jj_consume_token(IS_T);
6079     }
6080     if (!hasError) {
6081 m_sharedState->lastCompound=m_sharedState->current;
6082                           std::shared_ptr<Entry> clone=std::make_shared<Entry>(*m_sharedState->current);
6083                           clone->section=Entry::NAMESPACE_SEC;
6084                           clone->spec=VhdlDocGen::PACKAGE;
6085                           clone->name=s;
6086                           clone->startLine=outlineParser()->getLine(PACKAGE_T);
6087                           clone->bodyLine=outlineParser()->getLine(PACKAGE_T);
6088                           clone->protection=Package;
6089                           m_sharedState->current_root->moveToSubEntryAndKeep(clone);
6090                           outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
6091     }
6092     if (!hasError) {
6093     package_header();
6094     }
6095     if (!hasError) {
6096     package_declarative_part();
6097     }
6098     if (!hasError) {
6099     jj_consume_token(END_T);
6100     }
6101     if (!hasError) {
6102     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6103     case PACKAGE_T:{
6104       if (!hasError) {
6105       jj_consume_token(PACKAGE_T);
6106       }
6107       break;
6108       }
6109     default:
6110       jj_la1[160] = jj_gen;
6111       ;
6112     }
6113     }
6114     if (!hasError) {
6115     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6116     case SLSL_T:
6117     case STRINGLITERAL:
6118     case BASIC_IDENTIFIER:
6119     case EXTENDED_CHARACTER:{
6120       if (!hasError) {
6121       name();
6122       }
6123       break;
6124       }
6125     default:
6126       jj_la1[161] = jj_gen;
6127       ;
6128     }
6129     }
6130     if (!hasError) {
6131     jj_consume_token(SEMI_T);
6132     }
6133 m_sharedState->lastEntity=0;m_sharedState->lastCompound=0; m_sharedState->genLabels.resize(0);
6134 }
6135 
6136 
geninter()6137 void VhdlParser::geninter() {
6138     if (!hasError) {
6139     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6140     case GENERIC_T:{
6141       if (!hasError) {
6142       gen_interface_list();
6143       }
6144       if (!hasError) {
6145       jj_consume_token(SEMI_T);
6146       }
6147       if (!hasError) {
6148       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6149       case GENERIC_T:{
6150         if (!hasError) {
6151         gen_assoc_list();
6152         }
6153         if (!hasError) {
6154         jj_consume_token(SEMI_T);
6155         }
6156         break;
6157         }
6158       default:
6159         jj_la1[162] = jj_gen;
6160         ;
6161       }
6162       }
6163       break;
6164       }
6165     default:
6166       jj_la1[163] = jj_gen;
6167       ;
6168     }
6169     }
6170 }
6171 
6172 
package_declarative_item()6173 void VhdlParser::package_declarative_item() {
6174     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6175     case FUNCTION_T:
6176     case IMPURE_T:
6177     case PROCEDURE_T:
6178     case PURE_T:{
6179       if (!hasError) {
6180       subprogram_declaration();
6181       }
6182       break;
6183       }
6184     case TYPE_T:{
6185       if (!hasError) {
6186       type_declaration();
6187       }
6188       break;
6189       }
6190     case SUBTYPE_T:{
6191       if (!hasError) {
6192       subtype_declaration();
6193       }
6194       break;
6195       }
6196     case CONSTANT_T:{
6197       if (!hasError) {
6198       constant_declaration();
6199       }
6200       break;
6201       }
6202     case SIGNAL_T:{
6203       if (!hasError) {
6204       signal_declaration();
6205       }
6206       break;
6207       }
6208     case SHARED_T:
6209     case VARIABLE_T:{
6210       if (!hasError) {
6211       variable_declaration();
6212       }
6213       break;
6214       }
6215     case FILE_T:{
6216       if (!hasError) {
6217       file_declaration();
6218       }
6219       break;
6220       }
6221     case ALIAS_T:{
6222       if (!hasError) {
6223       alias_declaration();
6224       }
6225       break;
6226       }
6227     case COMPONENT_T:{
6228       if (!hasError) {
6229       component_declaration();
6230       }
6231       break;
6232       }
6233     default:
6234       jj_la1[164] = jj_gen;
6235       if (jj_2_63(2147483647)) {
6236         if (!hasError) {
6237         attribute_declaration();
6238         }
6239       } else {
6240         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6241         case ATTRIBUTE_T:{
6242           if (!hasError) {
6243           attribute_specification();
6244           }
6245           break;
6246           }
6247         case DISCONNECT_T:{
6248           if (!hasError) {
6249           disconnection_specification();
6250           }
6251           break;
6252           }
6253         case USE_T:{
6254           if (!hasError) {
6255           use_clause();
6256           }
6257           break;
6258           }
6259         default:
6260           jj_la1[165] = jj_gen;
6261           if (jj_2_64(3)) {
6262             if (!hasError) {
6263             group_template_declaration();
6264             }
6265           } else {
6266             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6267             case GROUP_T:{
6268               if (!hasError) {
6269               group_declaration();
6270               }
6271               break;
6272               }
6273             default:
6274               jj_la1[166] = jj_gen;
6275               if (jj_2_65(5)) {
6276                 if (!hasError) {
6277                 package_instantiation_declaration();
6278                 }
6279               } else {
6280                 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6281                 case PACKAGE_T:{
6282                   if (!hasError) {
6283                   package_declaration();
6284                   }
6285                   break;
6286                   }
6287                 default:
6288                   jj_la1[167] = jj_gen;
6289                   jj_consume_token(-1);
6290                   errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
6291                 }
6292               }
6293             }
6294           }
6295         }
6296       }
6297     }
6298 }
6299 
6300 
package_declarative_part()6301 void VhdlParser::package_declarative_part() {
6302     if (!hasError) {
6303     while (!hasError) {
6304       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6305       case ALIAS_T:
6306       case ATTRIBUTE_T:
6307       case COMPONENT_T:
6308       case CONSTANT_T:
6309       case DISCONNECT_T:
6310       case FILE_T:
6311       case FUNCTION_T:
6312       case GROUP_T:
6313       case IMPURE_T:
6314       case PACKAGE_T:
6315       case PROCEDURE_T:
6316       case PURE_T:
6317       case SIGNAL_T:
6318       case SHARED_T:
6319       case SUBTYPE_T:
6320       case TYPE_T:
6321       case USE_T:
6322       case VARIABLE_T:{
6323         ;
6324         break;
6325         }
6326       default:
6327         jj_la1[168] = jj_gen;
6328         goto end_label_30;
6329       }
6330       if (!hasError) {
6331       package_declarative_item();
6332       }
6333     }
6334     end_label_30: ;
6335     }
6336 }
6337 
6338 
parameter_specification()6339 QCString VhdlParser::parameter_specification() {QCString s,s1;
6340     if (!hasError) {
6341     s = identifier();
6342     }
6343     if (!hasError) {
6344     jj_consume_token(IN_T);
6345     }
6346     if (!hasError) {
6347     s1 = discrete_range();
6348     }
6349 return s+" in "+s1;
6350 assert(false);
6351 }
6352 
6353 
physical_literal()6354 QCString VhdlParser::physical_literal() {QCString s,s1;
6355     if (!hasError) {
6356     if (jj_2_66(2147483647)) {
6357       if (!hasError) {
6358       s = abstract_literal();
6359       }
6360     } else {
6361       ;
6362     }
6363     }
6364     if (!hasError) {
6365     s1 = name();
6366     }
6367 s+=" ";s+=s1;s.prepend(" "); return s;
6368 assert(false);
6369 }
6370 
6371 
physical_type_definition()6372 QCString VhdlParser::physical_type_definition() {QCString s,s1,s2;Token *t=0;
6373     if (!hasError) {
6374     t = jj_consume_token(UNITS_T);
6375     }
6376     if (!hasError) {
6377     s = identifier();
6378     }
6379     if (!hasError) {
6380     jj_consume_token(SEMI_T);
6381     }
6382     if (!hasError) {
6383 outlineParser()->addVhdlType(s.data(),t->beginLine,Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);
6384     }
6385     if (!hasError) {
6386     while (!hasError) {
6387       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6388       case BASIC_IDENTIFIER:
6389       case EXTENDED_CHARACTER:{
6390         ;
6391         break;
6392         }
6393       default:
6394         jj_la1[169] = jj_gen;
6395         goto end_label_31;
6396       }
6397       if (!hasError) {
6398       s1 = secondary_unit_declaration();
6399       }
6400     }
6401     end_label_31: ;
6402     }
6403     if (!hasError) {
6404     jj_consume_token(END_T);
6405     }
6406     if (!hasError) {
6407     jj_consume_token(UNITS_T);
6408     }
6409     if (!hasError) {
6410     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6411     case SLSL_T:
6412     case STRINGLITERAL:
6413     case BASIC_IDENTIFIER:
6414     case EXTENDED_CHARACTER:{
6415       if (!hasError) {
6416       name();
6417       }
6418       break;
6419       }
6420     default:
6421       jj_la1[170] = jj_gen;
6422       ;
6423     }
6424     }
6425 return s;
6426 assert(false);
6427 }
6428 
6429 
port_clause()6430 void VhdlParser::port_clause() {
6431     if (!hasError) {
6432     jj_consume_token(PORT_T);
6433     }
6434     if (!hasError) {
6435     jj_consume_token(LPAREN_T);
6436     }
6437     if (!hasError) {
6438     port_list();
6439     }
6440     if (!hasError) {
6441     jj_consume_token(RPAREN_T);
6442     }
6443     if (!hasError) {
6444     jj_consume_token(SEMI_T);
6445     }
6446 m_sharedState->currP=0;
6447 }
6448 
6449 
port_list()6450 QCString VhdlParser::port_list() {QCString s;
6451     if (!hasError) {
6452     s = interface_list();
6453     }
6454 return s;
6455 assert(false);
6456 }
6457 
6458 
port_map_aspect()6459 void VhdlParser::port_map_aspect() {
6460     if (!hasError) {
6461     jj_consume_token(PORT_T);
6462     }
6463     if (!hasError) {
6464     jj_consume_token(MAP_T);
6465     }
6466     if (!hasError) {
6467     jj_consume_token(LPAREN_T);
6468     }
6469     if (!hasError) {
6470     association_list();
6471     }
6472     if (!hasError) {
6473     jj_consume_token(RPAREN_T);
6474     }
6475 }
6476 
6477 
primary()6478 QCString VhdlParser::primary() {QCString s,s1;
6479     if (jj_2_67(2147483647)) {
6480       if (!hasError) {
6481       s = function_call();
6482       }
6483       if (!hasError) {
6484 return s;
6485       }
6486     } else if (jj_2_68(2147483647)) {
6487       if (!hasError) {
6488       jj_consume_token(LPAREN_T);
6489       }
6490       if (!hasError) {
6491       s1 = expression();
6492       }
6493       if (!hasError) {
6494       jj_consume_token(RPAREN_T);
6495       }
6496       if (!hasError) {
6497 s="("+s1+")"; return s;
6498       }
6499     } else if (jj_2_69(2147483647)) {
6500       if (!hasError) {
6501       s = qualified_expression();
6502       }
6503       if (!hasError) {
6504 return s;
6505       }
6506     } else if (jj_2_70(2147483647)) {
6507       if (!hasError) {
6508       s = type_conversion();
6509       }
6510       if (!hasError) {
6511 return s;
6512       }
6513     } else if (jj_2_71(2147483647)) {
6514       if (!hasError) {
6515       s = literal();
6516       }
6517       if (!hasError) {
6518 s.prepend(" ");return s;
6519       }
6520     } else if (jj_2_72(2147483647)) {
6521       if (!hasError) {
6522       s = name();
6523       }
6524       if (!hasError) {
6525 return s;
6526       }
6527     } else if (jj_2_73(2147483647)) {
6528       if (!hasError) {
6529       allocator();
6530       }
6531       if (!hasError) {
6532 return QCString();
6533       }
6534     } else {
6535       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6536       case LPAREN_T:{
6537         if (!hasError) {
6538         s = aggregate();
6539         }
6540         if (!hasError) {
6541 return s;
6542         }
6543         break;
6544         }
6545       default:
6546         jj_la1[171] = jj_gen;
6547         jj_consume_token(-1);
6548         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
6549       }
6550     }
6551 assert(false);
6552 }
6553 
6554 
primary_unit()6555 void VhdlParser::primary_unit() {
6556     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6557     case ENTITY_T:{
6558       if (!hasError) {
6559       entity_declaration();
6560       }
6561       break;
6562       }
6563     case CONFIGURATION_T:{
6564       if (!hasError) {
6565       configuration_declaration();
6566       }
6567       break;
6568       }
6569     default:
6570       jj_la1[172] = jj_gen;
6571       if (jj_2_74(2147483647)) {
6572         if (!hasError) {
6573         package_instantiation_declaration();
6574         }
6575       } else if (jj_2_75(4)) {
6576         if (!hasError) {
6577         interface_package_declaration();
6578         }
6579       } else {
6580         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6581         case PACKAGE_T:{
6582           if (!hasError) {
6583           package_declaration();
6584           }
6585           break;
6586           }
6587         case CONTEXT_T:{
6588           if (!hasError) {
6589           context_declaration();
6590           }
6591           break;
6592           }
6593         default:
6594           jj_la1[173] = jj_gen;
6595           jj_consume_token(-1);
6596           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
6597         }
6598       }
6599     }
6600 }
6601 
6602 
procedure_call()6603 QCString VhdlParser::procedure_call() {QCString s,s1;
6604     if (!hasError) {
6605     s = name();
6606     }
6607     if (!hasError) {
6608     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6609     case LPAREN_T:{
6610       if (!hasError) {
6611       jj_consume_token(LPAREN_T);
6612       }
6613       if (!hasError) {
6614       s1 = actual_parameter_part();
6615       }
6616       if (!hasError) {
6617       jj_consume_token(RPAREN_T);
6618       }
6619       if (!hasError) {
6620 s1.prepend("("); s1.append(")");
6621       }
6622       break;
6623       }
6624     default:
6625       jj_la1[174] = jj_gen;
6626       ;
6627     }
6628     }
6629 return s+s1;
6630 assert(false);
6631 }
6632 
6633 
procedure_call_statement()6634 QCString VhdlParser::procedure_call_statement() {QCString s,s1;
6635     if (!hasError) {
6636     if (jj_2_76(2)) {
6637       if (!hasError) {
6638       s = identifier();
6639       }
6640       if (!hasError) {
6641       jj_consume_token(COLON_T);
6642       }
6643       if (!hasError) {
6644 s+=":";
6645       }
6646     } else {
6647       ;
6648     }
6649     }
6650     if (!hasError) {
6651     s1 = procedure_call();
6652     }
6653     if (!hasError) {
6654     jj_consume_token(SEMI_T);
6655     }
6656 return s+s1+";";
6657 assert(false);
6658 }
6659 
6660 
process_declarative_item()6661 QCString VhdlParser::process_declarative_item() {QCString s;
6662     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6663     case FUNCTION_T:
6664     case IMPURE_T:
6665     case PROCEDURE_T:
6666     case PURE_T:{
6667       if (!hasError) {
6668       subprogram_declaration();
6669       }
6670       if (!hasError) {
6671 return QCString();
6672       }
6673       break;
6674       }
6675     case TYPE_T:{
6676       if (!hasError) {
6677       s = type_declaration();
6678       }
6679       if (!hasError) {
6680 return s;
6681       }
6682       break;
6683       }
6684     case SUBTYPE_T:{
6685       if (!hasError) {
6686       s = subtype_declaration();
6687       }
6688       if (!hasError) {
6689 return s;
6690       }
6691       break;
6692       }
6693     case CONSTANT_T:{
6694       if (!hasError) {
6695       s = constant_declaration();
6696       }
6697       if (!hasError) {
6698 return s;
6699       }
6700       break;
6701       }
6702     case SHARED_T:
6703     case VARIABLE_T:{
6704       if (!hasError) {
6705       s = variable_declaration();
6706       }
6707       if (!hasError) {
6708 return s;
6709       }
6710       break;
6711       }
6712     case FILE_T:{
6713       if (!hasError) {
6714       s = file_declaration();
6715       }
6716       if (!hasError) {
6717 return s;
6718       }
6719       break;
6720       }
6721     case ALIAS_T:{
6722       if (!hasError) {
6723       s = alias_declaration();
6724       }
6725       if (!hasError) {
6726 return s;
6727       }
6728       break;
6729       }
6730     default:
6731       jj_la1[175] = jj_gen;
6732       if (jj_2_77(3)) {
6733         if (!hasError) {
6734         s = attribute_declaration();
6735         }
6736         if (!hasError) {
6737 return s;
6738         }
6739       } else {
6740         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6741         case ATTRIBUTE_T:{
6742           if (!hasError) {
6743           s = attribute_specification();
6744           }
6745           if (!hasError) {
6746 return s;
6747           }
6748           break;
6749           }
6750         case USE_T:{
6751           if (!hasError) {
6752           s = use_clause();
6753           }
6754           if (!hasError) {
6755 return s;
6756           }
6757           break;
6758           }
6759         default:
6760           jj_la1[176] = jj_gen;
6761           if (jj_2_78(3)) {
6762             if (!hasError) {
6763             s = group_template_declaration();
6764             }
6765             if (!hasError) {
6766 return s;
6767             }
6768           } else {
6769             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6770             case GROUP_T:{
6771               if (!hasError) {
6772               s = group_declaration();
6773               }
6774               if (!hasError) {
6775 return s;
6776               }
6777               break;
6778               }
6779             default:
6780               jj_la1[177] = jj_gen;
6781               jj_consume_token(-1);
6782               errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
6783             }
6784           }
6785         }
6786       }
6787     }
6788 assert(false);
6789 }
6790 
6791 
process_declarative_part()6792 QCString VhdlParser::process_declarative_part() {QCString s,s1;
6793     if (!hasError) {
6794     while (!hasError) {
6795       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6796       case ALIAS_T:
6797       case ATTRIBUTE_T:
6798       case CONSTANT_T:
6799       case FILE_T:
6800       case FUNCTION_T:
6801       case GROUP_T:
6802       case IMPURE_T:
6803       case PROCEDURE_T:
6804       case PURE_T:
6805       case SHARED_T:
6806       case SUBTYPE_T:
6807       case TYPE_T:
6808       case USE_T:
6809       case VARIABLE_T:{
6810         ;
6811         break;
6812         }
6813       default:
6814         jj_la1[178] = jj_gen;
6815         goto end_label_32;
6816       }
6817       if (!hasError) {
6818       s1 = process_declarative_item();
6819       }
6820       if (!hasError) {
6821 s+=s1;
6822       }
6823     }
6824     end_label_32: ;
6825     }
6826 return s;
6827 assert(false);
6828 }
6829 
6830 
process_statement()6831 void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;Token *tok1=0;
6832     if (!hasError) {
6833     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6834     case BASIC_IDENTIFIER:
6835     case EXTENDED_CHARACTER:{
6836       if (!hasError) {
6837       s = identifier();
6838       }
6839       if (!hasError) {
6840       jj_consume_token(COLON_T);
6841       }
6842       break;
6843       }
6844     default:
6845       jj_la1[179] = jj_gen;
6846       ;
6847     }
6848     }
6849     if (!hasError) {
6850     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6851     case POSTPONED_T:{
6852       if (!hasError) {
6853       jj_consume_token(POSTPONED_T);
6854       }
6855       break;
6856       }
6857     default:
6858       jj_la1[180] = jj_gen;
6859       ;
6860     }
6861     }
6862     if (!hasError) {
6863     tok1 = jj_consume_token(PROCESS_T);
6864     }
6865     if (!hasError) {
6866 m_sharedState->currP=VhdlDocGen::PROCESS;
6867     m_sharedState->current->startLine=tok1->beginLine;
6868     m_sharedState->current->bodyLine=tok1->beginLine;
6869     }
6870     if (!hasError) {
6871     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6872     case LPAREN_T:{
6873       if (!hasError) {
6874       jj_consume_token(LPAREN_T);
6875       }
6876       if (!hasError) {
6877       if (!hasError) {
6878       s1 = sensitivity_list();
6879       }
6880       }
6881       if (!hasError) {
6882       jj_consume_token(RPAREN_T);
6883       }
6884       break;
6885       }
6886     default:
6887       jj_la1[181] = jj_gen;
6888       ;
6889     }
6890     }
6891     if (!hasError) {
6892     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6893     case IS_T:{
6894       if (!hasError) {
6895       jj_consume_token(IS_T);
6896       }
6897       break;
6898       }
6899     default:
6900       jj_la1[182] = jj_gen;
6901       ;
6902     }
6903     }
6904     if (!hasError) {
6905     s2 = process_declarative_part();
6906     }
6907     if (!hasError) {
6908 if (s2.data())
6909                 FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s2,QCString());
6910                 FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",QCString());
6911     }
6912     if (!hasError) {
6913     jj_consume_token(BEGIN_T);
6914     }
6915     if (!hasError) {
6916     process_statement_part();
6917     }
6918     if (!hasError) {
6919     jj_consume_token(END_T);
6920     }
6921     if (!hasError) {
6922     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6923     case POSTPONED_T:{
6924       if (!hasError) {
6925       jj_consume_token(POSTPONED_T);
6926       }
6927       break;
6928       }
6929     default:
6930       jj_la1[183] = jj_gen;
6931       ;
6932     }
6933     }
6934     if (!hasError) {
6935     jj_consume_token(PROCESS_T);
6936     }
6937     if (!hasError) {
6938     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6939     case BASIC_IDENTIFIER:
6940     case EXTENDED_CHARACTER:{
6941       if (!hasError) {
6942       identifier();
6943       }
6944       break;
6945       }
6946     default:
6947       jj_la1[184] = jj_gen;
6948       ;
6949     }
6950     }
6951     if (!hasError) {
6952     jj_consume_token(SEMI_T);
6953     }
6954 if(s.isEmpty())
6955             m_sharedState->currName=VhdlDocGen::getProcessNumber();
6956           else
6957             m_sharedState->currName=s;
6958           m_sharedState->current->name=m_sharedState->currName;
6959           m_sharedState->tempEntry=m_sharedState->current;
6960                   m_sharedState->tempEntry->type="";
6961           m_sharedState->current->endBodyLine=outlineParser()->getLine();
6962           m_sharedState->currP=0;
6963           if(tok)
6964             s1=tok->image;
6965           outlineParser()->createFunction(m_sharedState->currName.data(),VhdlDocGen::PROCESS,s1.data());
6966           outlineParser()->createFlow();
6967           m_sharedState->currName="";
6968           outlineParser()->newEntry();
6969 }
6970 
6971 
process_statement_part()6972 void VhdlParser::process_statement_part() {
6973     if (!hasError) {
6974     while (!hasError) {
6975       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
6976       case ASSERT_T:
6977       case CASE_T:
6978       case EXIT_T:
6979       case FOR_T:
6980       case IF_T:
6981       case LOOP_T:
6982       case NEXT_T:
6983       case NULL_T:
6984       case REPORT_T:
6985       case RETURN_T:
6986       case WAIT_T:
6987       case WHILE_T:
6988       case WITH_T:
6989       case LPAREN_T:
6990       case SLSL_T:
6991       case STRINGLITERAL:
6992       case BASIC_IDENTIFIER:
6993       case EXTENDED_CHARACTER:{
6994         ;
6995         break;
6996         }
6997       default:
6998         jj_la1[185] = jj_gen;
6999         goto end_label_33;
7000       }
7001       if (!hasError) {
7002       sequential_statement();
7003       }
7004     }
7005     end_label_33: ;
7006     }
7007 }
7008 
7009 
qualified_expression()7010 QCString VhdlParser::qualified_expression() {QCString s,s1;
7011     if (!hasError) {
7012     s1 = identifier();
7013     }
7014     if (!hasError) {
7015     jj_consume_token(APOSTROPHE_T);
7016     }
7017     if (!hasError) {
7018 s=s1+"'";
7019     }
7020     if (!hasError) {
7021     if (jj_2_79(2147483647)) {
7022       if (!hasError) {
7023       s1 = aggregate();
7024       }
7025       if (!hasError) {
7026 s+=s1;
7027       }
7028     } else {
7029       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7030       case LPAREN_T:{
7031         if (!hasError) {
7032         jj_consume_token(LPAREN_T);
7033         }
7034         if (!hasError) {
7035         s1 = expression();
7036         }
7037         if (!hasError) {
7038         jj_consume_token(RPAREN_T);
7039         }
7040         if (!hasError) {
7041 s+="(";s+=s1;s+=")";
7042         }
7043         break;
7044         }
7045       default:
7046         jj_la1[186] = jj_gen;
7047         jj_consume_token(-1);
7048         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7049       }
7050     }
7051     }
7052 return s;
7053 assert(false);
7054 }
7055 
7056 
range()7057 QCString VhdlParser::range() {QCString s,s1,s2;
7058     if (jj_2_80(2147483647)) {
7059       if (!hasError) {
7060       s = simple_expression();
7061       }
7062       if (!hasError) {
7063       s1 = direction();
7064       }
7065       if (!hasError) {
7066       s2 = simple_expression();
7067       }
7068       if (!hasError) {
7069 return s+" "+s1+" "+s2;
7070       }
7071     } else if (jj_2_81(2147483647)) {
7072       if (!hasError) {
7073       s = attribute_name();
7074       }
7075       if (!hasError) {
7076 return s;
7077       }
7078     } else {
7079       jj_consume_token(-1);
7080       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7081     }
7082 assert(false);
7083 }
7084 
7085 
range_constraint()7086 QCString VhdlParser::range_constraint() {QCString s,s1;
7087     if (!hasError) {
7088     jj_consume_token(RANGE_T);
7089     }
7090     if (!hasError) {
7091     s = range();
7092     }
7093 return " range "+s;
7094 assert(false);
7095 }
7096 
7097 
record_type_definition()7098 void VhdlParser::record_type_definition() {
7099     if (!hasError) {
7100     jj_consume_token(RECORD_T);
7101     }
7102     if (!hasError) {
7103     while (!hasError) {
7104       if (!hasError) {
7105       element_declaration();
7106       }
7107       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7108       case SLSL_T:
7109       case STRINGLITERAL:
7110       case BASIC_IDENTIFIER:
7111       case EXTENDED_CHARACTER:{
7112         ;
7113         break;
7114         }
7115       default:
7116         jj_la1[187] = jj_gen;
7117         goto end_label_34;
7118       }
7119     }
7120     end_label_34: ;
7121     }
7122     if (!hasError) {
7123     jj_consume_token(END_T);
7124     }
7125     if (!hasError) {
7126     jj_consume_token(RECORD_T);
7127     }
7128     if (!hasError) {
7129     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7130     case SLSL_T:
7131     case STRINGLITERAL:
7132     case BASIC_IDENTIFIER:
7133     case EXTENDED_CHARACTER:{
7134       if (!hasError) {
7135       name();
7136       }
7137       break;
7138       }
7139     default:
7140       jj_la1[188] = jj_gen;
7141       ;
7142     }
7143     }
7144 }
7145 
7146 
relation()7147 QCString VhdlParser::relation() {QCString s,s1,s2;
7148     if (!hasError) {
7149     s = shift_expression();
7150     }
7151     if (!hasError) {
7152     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7153     case LESSTHAN_T:
7154     case GREATERTHAN_T:
7155     case LT_T:
7156     case GT_T:
7157     case EQU_T:
7158     case NOTEQU_T:
7159     case QGT_T:
7160     case QLT_T:
7161     case QG_T:
7162     case QL_T:
7163     case QEQU_T:
7164     case QNEQU_T:{
7165       if (!hasError) {
7166       s1 = relation_operator();
7167       }
7168       if (!hasError) {
7169       s2 = shift_expression();
7170       }
7171       break;
7172       }
7173     default:
7174       jj_la1[189] = jj_gen;
7175       ;
7176     }
7177     }
7178 return s+s1+s2;
7179 assert(false);
7180 }
7181 
7182 
relation_operator()7183 QCString VhdlParser::relation_operator() {
7184     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7185     case LT_T:{
7186       if (!hasError) {
7187       jj_consume_token(LT_T);
7188       }
7189       if (!hasError) {
7190 return "<";
7191       }
7192       break;
7193       }
7194     case GT_T:{
7195       if (!hasError) {
7196       jj_consume_token(GT_T);
7197       }
7198       if (!hasError) {
7199 return ">";
7200       }
7201       break;
7202       }
7203     case EQU_T:{
7204       if (!hasError) {
7205       jj_consume_token(EQU_T);
7206       }
7207       if (!hasError) {
7208 return "=";
7209       }
7210       break;
7211       }
7212     case GREATERTHAN_T:{
7213       if (!hasError) {
7214       jj_consume_token(GREATERTHAN_T);
7215       }
7216       if (!hasError) {
7217 return ">=";
7218       }
7219       break;
7220       }
7221     case LESSTHAN_T:{
7222       if (!hasError) {
7223       jj_consume_token(LESSTHAN_T);
7224       }
7225       if (!hasError) {
7226 return "<=";
7227       }
7228       break;
7229       }
7230     case NOTEQU_T:{
7231       if (!hasError) {
7232       jj_consume_token(NOTEQU_T);
7233       }
7234       if (!hasError) {
7235 return "/=";
7236       }
7237       break;
7238       }
7239     case QGT_T:{
7240       if (!hasError) {
7241       jj_consume_token(QGT_T);
7242       }
7243       if (!hasError) {
7244 return "?>=";
7245       }
7246       break;
7247       }
7248     case QLT_T:{
7249       if (!hasError) {
7250       jj_consume_token(QLT_T);
7251       }
7252       if (!hasError) {
7253 return "?<=";
7254       }
7255       break;
7256       }
7257     case QG_T:{
7258       if (!hasError) {
7259       jj_consume_token(QG_T);
7260       }
7261       if (!hasError) {
7262 return "?>";
7263       }
7264       break;
7265       }
7266     case QL_T:{
7267       if (!hasError) {
7268       jj_consume_token(QL_T);
7269       }
7270       if (!hasError) {
7271 return "?<";
7272       }
7273       break;
7274       }
7275     case QEQU_T:{
7276       if (!hasError) {
7277       jj_consume_token(QEQU_T);
7278       }
7279       if (!hasError) {
7280 return "?=";
7281       }
7282       break;
7283       }
7284     case QNEQU_T:{
7285       if (!hasError) {
7286       jj_consume_token(QNEQU_T);
7287       }
7288       if (!hasError) {
7289 return "?/=";
7290       }
7291       break;
7292       }
7293     default:
7294       jj_la1[190] = jj_gen;
7295       jj_consume_token(-1);
7296       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7297     }
7298 assert(false);
7299 }
7300 
7301 
report_statement()7302 QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2;
7303     if (!hasError) {
7304     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7305     case BASIC_IDENTIFIER:
7306     case EXTENDED_CHARACTER:{
7307       if (!hasError) {
7308       s = identifier();
7309       }
7310       if (!hasError) {
7311       t = jj_consume_token(COLON_T);
7312       }
7313       break;
7314       }
7315     default:
7316       jj_la1[191] = jj_gen;
7317       ;
7318     }
7319     }
7320     if (!hasError) {
7321     jj_consume_token(REPORT_T);
7322     }
7323     if (!hasError) {
7324     s1 = expression();
7325     }
7326     if (!hasError) {
7327     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7328     case SEVERITY_T:{
7329       if (!hasError) {
7330       t1 = jj_consume_token(SEVERITY_T);
7331       }
7332       if (!hasError) {
7333       s2 = expression();
7334       }
7335       break;
7336       }
7337     default:
7338       jj_la1[192] = jj_gen;
7339       ;
7340     }
7341     }
7342     if (!hasError) {
7343     jj_consume_token(SEMI_T);
7344     }
7345 if(t) s.append(":");
7346         s1.prepend(" report ");
7347         if(t1) s2.prepend(" severity ");
7348         return s+s1+s2+";";
7349 assert(false);
7350 }
7351 
7352 
return_statement()7353 QCString VhdlParser::return_statement() {QCString s,s1;
7354     if (!hasError) {
7355     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7356     case BASIC_IDENTIFIER:
7357     case EXTENDED_CHARACTER:{
7358       if (!hasError) {
7359       s = identifier();
7360       }
7361       if (!hasError) {
7362       jj_consume_token(COLON_T);
7363       }
7364       if (!hasError) {
7365 s+=":";
7366       }
7367       break;
7368       }
7369     default:
7370       jj_la1[193] = jj_gen;
7371       ;
7372     }
7373     }
7374     if (!hasError) {
7375     jj_consume_token(RETURN_T);
7376     }
7377     if (!hasError) {
7378     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7379     case ABS_T:
7380     case AND_T:
7381     case NAND_T:
7382     case NEW_T:
7383     case NOR_T:
7384     case NOT_T:
7385     case NULL_T:
7386     case OR_T:
7387     case XOR_T:
7388     case XNOR_T:
7389     case LPAREN_T:
7390     case PLUS_T:
7391     case MINUS_T:
7392     case SLSL_T:
7393     case QQ_T:
7394     case INTEGER:
7395     case STRINGLITERAL:
7396     case BASIC_IDENTIFIER:
7397     case EXTENDED_CHARACTER:
7398     case CHARACTER_LITERAL:
7399     case DECIMAL_LITERAL:
7400     case BASED_LITERAL:
7401     case BIT_STRING_LITERAL:{
7402       if (!hasError) {
7403       s1 = expression();
7404       }
7405       break;
7406       }
7407     default:
7408       jj_la1[194] = jj_gen;
7409       ;
7410     }
7411     }
7412     if (!hasError) {
7413     jj_consume_token(SEMI_T);
7414     }
7415 return s+" return "+s1+";";
7416 assert(false);
7417 }
7418 
7419 
scalar_type_definition()7420 QCString VhdlParser::scalar_type_definition() {QCString s,s1;
7421     if (jj_2_82(2147483647)) {
7422       if (!hasError) {
7423       s = enumeration_type_definition();
7424       }
7425       if (!hasError) {
7426 return s;
7427       }
7428     } else {
7429       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7430       case RANGE_T:{
7431         if (!hasError) {
7432         s = range_constraint();
7433         }
7434         if (!hasError) {
7435         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7436         case UNITS_T:{
7437           if (!hasError) {
7438           s1 = physical_type_definition();
7439           }
7440           break;
7441           }
7442         default:
7443           jj_la1[195] = jj_gen;
7444           ;
7445         }
7446         }
7447         if (!hasError) {
7448 return s+" "+s1;
7449         }
7450         break;
7451         }
7452       default:
7453         jj_la1[196] = jj_gen;
7454         jj_consume_token(-1);
7455         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7456       }
7457     }
7458 assert(false);
7459 }
7460 
7461 
secondary_unit()7462 void VhdlParser::secondary_unit() {
7463     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7464     case ARCHITECTURE_T:{
7465       if (!hasError) {
7466       architecture_body();
7467       }
7468       break;
7469       }
7470     case PACKAGE_T:{
7471       if (!hasError) {
7472       package_body();
7473       }
7474       break;
7475       }
7476     default:
7477       jj_la1[197] = jj_gen;
7478       jj_consume_token(-1);
7479       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7480     }
7481 }
7482 
7483 
secondary_unit_declaration()7484 QCString VhdlParser::secondary_unit_declaration() {QCString s,s1;Token *t1=0;
7485     if (!hasError) {
7486     s = identifier();
7487     }
7488     if (!hasError) {
7489     t1 = jj_consume_token(EQU_T);
7490     }
7491     if (!hasError) {
7492     s1 = physical_literal();
7493     }
7494     if (!hasError) {
7495     jj_consume_token(SEMI_T);
7496     }
7497 outlineParser()->addVhdlType(s.data(),t1->beginLine,Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
7498    return s+"="+s1;
7499 assert(false);
7500 }
7501 
7502 
selected_name()7503 QCString VhdlParser::selected_name() {QCString s,s1;
7504     if (!hasError) {
7505     s = identifier();
7506     }
7507     if (!hasError) {
7508     jj_consume_token(DOT_T);
7509     }
7510     if (!hasError) {
7511     s1 = suffix();
7512     }
7513 return s+"."+s1;
7514 assert(false);
7515 }
7516 
7517 
selected_signal_assignment()7518 void VhdlParser::selected_signal_assignment() {
7519     if (!hasError) {
7520     jj_consume_token(WITH_T);
7521     }
7522     if (!hasError) {
7523     expression();
7524     }
7525     if (!hasError) {
7526     jj_consume_token(SELECT_T);
7527     }
7528     if (!hasError) {
7529     target();
7530     }
7531     if (!hasError) {
7532     jj_consume_token(LESSTHAN_T);
7533     }
7534     if (!hasError) {
7535     options();
7536     }
7537     if (!hasError) {
7538     selected_waveforms();
7539     }
7540     if (!hasError) {
7541     jj_consume_token(SEMI_T);
7542     }
7543 }
7544 
7545 
selected_waveforms()7546 void VhdlParser::selected_waveforms() {
7547     if (!hasError) {
7548     waveform();
7549     }
7550     if (!hasError) {
7551     jj_consume_token(WHEN_T);
7552     }
7553     if (!hasError) {
7554     choices();
7555     }
7556     if (!hasError) {
7557     while (!hasError) {
7558       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7559       case COMMA_T:{
7560         ;
7561         break;
7562         }
7563       default:
7564         jj_la1[198] = jj_gen;
7565         goto end_label_35;
7566       }
7567       if (!hasError) {
7568       jj_consume_token(COMMA_T);
7569       }
7570       if (!hasError) {
7571       waveform();
7572       }
7573       if (!hasError) {
7574       jj_consume_token(WHEN_T);
7575       }
7576       if (!hasError) {
7577       choices();
7578       }
7579     }
7580     end_label_35: ;
7581     }
7582 }
7583 
7584 
sensitivity_clause()7585 QCString VhdlParser::sensitivity_clause() {QCString s;
7586     if (!hasError) {
7587     jj_consume_token(ON_T);
7588     }
7589     if (!hasError) {
7590     s = sensitivity_list();
7591     }
7592 s.prepend(" on ");
7593   return s;
7594 assert(false);
7595 }
7596 
7597 
sensitivity_list()7598 QCString VhdlParser::sensitivity_list() {QCString s,s1;Token* tok=0;
7599     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7600     case ALL_T:{
7601       if (!hasError) {
7602       tok = jj_consume_token(ALL_T);
7603       }
7604       if (!hasError) {
7605 if(tok) return "all" ;
7606       }
7607       break;
7608       }
7609     case SLSL_T:
7610     case STRINGLITERAL:
7611     case BASIC_IDENTIFIER:
7612     case EXTENDED_CHARACTER:{
7613       if (!hasError) {
7614       s = name();
7615       }
7616       if (!hasError) {
7617       while (!hasError) {
7618         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7619         case COMMA_T:{
7620           ;
7621           break;
7622           }
7623         default:
7624           jj_la1[199] = jj_gen;
7625           goto end_label_36;
7626         }
7627         if (!hasError) {
7628         jj_consume_token(COMMA_T);
7629         }
7630         if (!hasError) {
7631         s1 = name();
7632         }
7633         if (!hasError) {
7634 s+=",";s+=s1;
7635         }
7636       }
7637       end_label_36: ;
7638       }
7639       if (!hasError) {
7640 return s;
7641       }
7642       break;
7643       }
7644     default:
7645       jj_la1[200] = jj_gen;
7646       jj_consume_token(-1);
7647       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7648     }
7649 assert(false);
7650 }
7651 
7652 
sequence_of_statement()7653 QCString VhdlParser::sequence_of_statement() {QCString s,s1;
7654     if (!hasError) {
7655     while (!hasError) {
7656       if (jj_2_83(3)) {
7657         ;
7658       } else {
7659         goto end_label_37;
7660       }
7661       if (!hasError) {
7662       s1 = sequential_statement();
7663       }
7664       if (!hasError) {
7665 s+=s1;
7666       }
7667     }
7668     end_label_37: ;
7669     }
7670 return s;
7671 assert(false);
7672 }
7673 
7674 
sequential_statement()7675 QCString VhdlParser::sequential_statement() {QCString s;
7676     if (jj_2_84(2147483647)) {
7677       if (!hasError) {
7678       s = signal_assignment_statement();
7679       }
7680       if (!hasError) {
7681 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7682       }
7683     } else if (jj_2_85(3)) {
7684       if (!hasError) {
7685       s = assertion_statement();
7686       }
7687       if (!hasError) {
7688 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7689       }
7690     } else if (jj_2_86(3)) {
7691       if (!hasError) {
7692       s = report_statement();
7693       }
7694       if (!hasError) {
7695 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7696       }
7697     } else if (jj_2_87(3)) {
7698       if (!hasError) {
7699       s = wait_statement();
7700       }
7701       if (!hasError) {
7702 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7703       }
7704     } else if (jj_2_88(2147483647)) {
7705       if (!hasError) {
7706       s = variable_assignment_statement();
7707       }
7708       if (!hasError) {
7709 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7710       }
7711     } else if (jj_2_89(3)) {
7712       if (!hasError) {
7713       s = procedure_call_statement();
7714       }
7715       if (!hasError) {
7716 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7717       }
7718     } else if (jj_2_90(3)) {
7719       if (!hasError) {
7720       if_statement();
7721       }
7722       if (!hasError) {
7723 return s;
7724       }
7725     } else if (jj_2_91(3)) {
7726       if (!hasError) {
7727       case_statement();
7728       }
7729       if (!hasError) {
7730 return s;
7731       }
7732     } else if (jj_2_92(3)) {
7733       if (!hasError) {
7734       loop_statement();
7735       }
7736       if (!hasError) {
7737 return s;
7738       }
7739     } else if (jj_2_93(3)) {
7740       if (!hasError) {
7741       s = next_statement();
7742       }
7743       if (!hasError) {
7744 return s;
7745       }
7746     } else if (jj_2_94(3)) {
7747       if (!hasError) {
7748       s = exit_statement();
7749       }
7750       if (!hasError) {
7751 return s;
7752       }
7753     } else if (jj_2_95(3)) {
7754       if (!hasError) {
7755       s = return_statement();
7756       }
7757       if (!hasError) {
7758 FlowChart::addFlowChart(FlowChart::RETURN_NO,s,QCString());return s;
7759       }
7760     } else {
7761       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7762       case NULL_T:
7763       case BASIC_IDENTIFIER:
7764       case EXTENDED_CHARACTER:{
7765         if (!hasError) {
7766         s = null_statement();
7767         }
7768         if (!hasError) {
7769 FlowChart::addFlowChart(FlowChart::TEXT_NO,s,QCString());return s;
7770         }
7771         break;
7772         }
7773       default:
7774         jj_la1[201] = jj_gen;
7775         jj_consume_token(-1);
7776         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7777       }
7778     }
7779 assert(false);
7780 }
7781 
7782 
shift_expression()7783 QCString VhdlParser::shift_expression() {QCString s,s1,s2;
7784     if (!hasError) {
7785     s = simple_expression();
7786     }
7787     if (!hasError) {
7788     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7789     case ROL_T:
7790     case ROR_T:
7791     case SLA_T:
7792     case SLL_T:
7793     case SRA_T:
7794     case SRL_T:{
7795       if (!hasError) {
7796       s1 = shift_operator();
7797       }
7798       if (!hasError) {
7799       s2 = simple_expression();
7800       }
7801       break;
7802       }
7803     default:
7804       jj_la1[202] = jj_gen;
7805       ;
7806     }
7807     }
7808 return s+s1+s2;
7809 assert(false);
7810 }
7811 
7812 
shift_operator()7813 QCString VhdlParser::shift_operator() {
7814     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7815     case SLL_T:{
7816       if (!hasError) {
7817       jj_consume_token(SLL_T);
7818       }
7819       if (!hasError) {
7820 return "sll";
7821       }
7822       break;
7823       }
7824     case SRL_T:{
7825       if (!hasError) {
7826       jj_consume_token(SRL_T);
7827       }
7828       if (!hasError) {
7829 return "srl";
7830       }
7831       break;
7832       }
7833     case SLA_T:{
7834       if (!hasError) {
7835       jj_consume_token(SLA_T);
7836       }
7837       if (!hasError) {
7838 return "sla";
7839       }
7840       break;
7841       }
7842     case SRA_T:{
7843       if (!hasError) {
7844       jj_consume_token(SRA_T);
7845       }
7846       if (!hasError) {
7847 return "sra";
7848       }
7849       break;
7850       }
7851     case ROL_T:{
7852       if (!hasError) {
7853       jj_consume_token(ROL_T);
7854       }
7855       if (!hasError) {
7856 return "rol";
7857       }
7858       break;
7859       }
7860     case ROR_T:{
7861       if (!hasError) {
7862       jj_consume_token(ROR_T);
7863       }
7864       if (!hasError) {
7865 return "ror";
7866       }
7867       break;
7868       }
7869     default:
7870       jj_la1[203] = jj_gen;
7871       jj_consume_token(-1);
7872       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7873     }
7874 assert(false);
7875 }
7876 
7877 
sign()7878 QCString VhdlParser::sign() {
7879     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7880     case PLUS_T:{
7881       if (!hasError) {
7882       jj_consume_token(PLUS_T);
7883       }
7884       if (!hasError) {
7885 return "+";
7886       }
7887       break;
7888       }
7889     case MINUS_T:{
7890       if (!hasError) {
7891       jj_consume_token(MINUS_T);
7892       }
7893       if (!hasError) {
7894 return "-";
7895       }
7896       break;
7897       }
7898     default:
7899       jj_la1[204] = jj_gen;
7900       jj_consume_token(-1);
7901       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7902     }
7903 assert(false);
7904 }
7905 
7906 
signal_assignment_statement()7907 QCString VhdlParser::signal_assignment_statement() {QCString s,s1,s2,s3;
7908     if (jj_2_97(2147483647)) {
7909       if (!hasError) {
7910       conditional_signal_assignment_wave();
7911       }
7912       if (!hasError) {
7913 return QCString();
7914       }
7915     } else if (jj_2_98(2147483647)) {
7916       if (!hasError) {
7917       selected_signal_assignment_wave();
7918       }
7919       if (!hasError) {
7920 return QCString();
7921       }
7922     } else {
7923       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7924       case LPAREN_T:
7925       case SLSL_T:
7926       case STRINGLITERAL:
7927       case BASIC_IDENTIFIER:
7928       case EXTENDED_CHARACTER:{
7929         if (!hasError) {
7930         if (jj_2_96(2)) {
7931           if (!hasError) {
7932           s = identifier();
7933           }
7934           if (!hasError) {
7935           jj_consume_token(COLON_T);
7936           }
7937           if (!hasError) {
7938 s+=":";
7939           }
7940         } else {
7941           ;
7942         }
7943         }
7944         if (!hasError) {
7945         s1 = target();
7946         }
7947         if (!hasError) {
7948         jj_consume_token(LESSTHAN_T);
7949         }
7950         if (!hasError) {
7951         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
7952         case INERTIAL_T:
7953         case REJECT_T:
7954         case TRANSPORT_T:{
7955           if (!hasError) {
7956           s2 = delay_mechanism();
7957           }
7958           break;
7959           }
7960         default:
7961           jj_la1[205] = jj_gen;
7962           ;
7963         }
7964         }
7965         if (!hasError) {
7966         s3 = waveform();
7967         }
7968         if (!hasError) {
7969         jj_consume_token(SEMI_T);
7970         }
7971         if (!hasError) {
7972 return s+s1+"<="+s2+s3+";";
7973         }
7974         break;
7975         }
7976       default:
7977         jj_la1[206] = jj_gen;
7978         jj_consume_token(-1);
7979         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
7980       }
7981     }
7982 assert(false);
7983 }
7984 
7985 
semi()7986 void VhdlParser::semi() {
7987     if (!hasError) {
7988     jj_consume_token(SEMI_T);
7989     }
7990 }
7991 
7992 
signal_declaration()7993 void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;
7994     if (!hasError) {
7995     jj_consume_token(SIGNAL_T);
7996     }
7997     if (!hasError) {
7998     s = identifier_list();
7999     }
8000     if (!hasError) {
8001     jj_consume_token(COLON_T);
8002     }
8003     if (!hasError) {
8004     s1 = subtype_indication();
8005     }
8006     if (!hasError) {
8007     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8008     case BUS_T:
8009     case REGISTER_T:{
8010       if (!hasError) {
8011       s2 = signal_kind();
8012       }
8013       break;
8014       }
8015     default:
8016       jj_la1[207] = jj_gen;
8017       ;
8018     }
8019     }
8020     if (!hasError) {
8021     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8022     case VARASSIGN_T:{
8023       if (!hasError) {
8024       tok = jj_consume_token(VARASSIGN_T);
8025       }
8026       if (!hasError) {
8027       s3 = expression();
8028       }
8029       break;
8030       }
8031     default:
8032       jj_la1[208] = jj_gen;
8033       ;
8034     }
8035     }
8036     if (!hasError) {
8037     jj_consume_token(SEMI_T);
8038     }
8039 if(tok)
8040       s3.prepend(":=");
8041      s4=s1+s2+s3;
8042      outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
8043 }
8044 
8045 
signal_kind()8046 QCString VhdlParser::signal_kind() {
8047     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8048     case REGISTER_T:{
8049       if (!hasError) {
8050       jj_consume_token(REGISTER_T);
8051       }
8052       if (!hasError) {
8053 return "register";
8054       }
8055       break;
8056       }
8057     case BUS_T:{
8058       if (!hasError) {
8059       jj_consume_token(BUS_T);
8060       }
8061       if (!hasError) {
8062 return "bus";
8063       }
8064       break;
8065       }
8066     default:
8067       jj_la1[209] = jj_gen;
8068       jj_consume_token(-1);
8069       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8070     }
8071 assert(false);
8072 }
8073 
8074 
signal_list()8075 QCString VhdlParser::signal_list() {QCString s,s1;
8076     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8077     case SLSL_T:
8078     case STRINGLITERAL:
8079     case BASIC_IDENTIFIER:
8080     case EXTENDED_CHARACTER:{
8081       if (!hasError) {
8082       s = name();
8083       }
8084       if (!hasError) {
8085       while (!hasError) {
8086         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8087         case COMMA_T:{
8088           ;
8089           break;
8090           }
8091         default:
8092           jj_la1[210] = jj_gen;
8093           goto end_label_38;
8094         }
8095         if (!hasError) {
8096         jj_consume_token(COMMA_T);
8097         }
8098         if (!hasError) {
8099         s1 = name();
8100         }
8101         if (!hasError) {
8102 s+=",";s+=s1;
8103         }
8104       }
8105       end_label_38: ;
8106       }
8107       break;
8108       }
8109     case OTHER_T:{
8110       if (!hasError) {
8111       jj_consume_token(OTHER_T);
8112       }
8113       if (!hasError) {
8114 return "other";
8115       }
8116       break;
8117       }
8118     case ALL_T:{
8119       if (!hasError) {
8120       jj_consume_token(ALL_T);
8121       }
8122       if (!hasError) {
8123 return "all";
8124       }
8125       break;
8126       }
8127     default:
8128       jj_la1[211] = jj_gen;
8129       jj_consume_token(-1);
8130       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8131     }
8132 assert(false);
8133 }
8134 
8135 
signature()8136 QCString VhdlParser::signature() {QCString s,s1,s2;
8137     if (!hasError) {
8138     jj_consume_token(LBRACKET_T);
8139     }
8140     if (!hasError) {
8141     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8142     case SLSL_T:
8143     case STRINGLITERAL:
8144     case BASIC_IDENTIFIER:
8145     case EXTENDED_CHARACTER:{
8146       if (!hasError) {
8147       s = name();
8148       }
8149       if (!hasError) {
8150       while (!hasError) {
8151         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8152         case COMMA_T:{
8153           ;
8154           break;
8155           }
8156         default:
8157           jj_la1[212] = jj_gen;
8158           goto end_label_39;
8159         }
8160         if (!hasError) {
8161         jj_consume_token(COMMA_T);
8162         }
8163         if (!hasError) {
8164         s1 = name();
8165         }
8166         if (!hasError) {
8167 s+=",";s+=s1;
8168         }
8169       }
8170       end_label_39: ;
8171       }
8172       break;
8173       }
8174     default:
8175       jj_la1[213] = jj_gen;
8176       ;
8177     }
8178     }
8179     if (!hasError) {
8180     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8181     case RETURN_T:{
8182       if (!hasError) {
8183       jj_consume_token(RETURN_T);
8184       }
8185       if (!hasError) {
8186       s1 = name();
8187       }
8188       if (!hasError) {
8189 s+="return ";s+=s1;
8190       }
8191       break;
8192       }
8193     default:
8194       jj_la1[214] = jj_gen;
8195       ;
8196     }
8197     }
8198     if (!hasError) {
8199     jj_consume_token(RBRACKET_T);
8200     }
8201 s1="["+s+"]";return s1;
8202 assert(false);
8203 }
8204 
8205 
simple_expression()8206 QCString VhdlParser::simple_expression() {QCString s,s1,s2;
8207     if (!hasError) {
8208     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8209     case PLUS_T:
8210     case MINUS_T:{
8211       if (!hasError) {
8212       s = sign();
8213       }
8214       break;
8215       }
8216     default:
8217       jj_la1[215] = jj_gen;
8218       ;
8219     }
8220     }
8221     if (!hasError) {
8222     s1 = term();
8223     }
8224     if (!hasError) {
8225 s+=s1;
8226     }
8227     if (!hasError) {
8228     while (!hasError) {
8229       if (jj_2_99(2147483647)) {
8230         ;
8231       } else {
8232         goto end_label_40;
8233       }
8234       if (!hasError) {
8235       s1 = adding_operator();
8236       }
8237       if (!hasError) {
8238       s2 = term();
8239       }
8240       if (!hasError) {
8241 s+=s1;s+=s2;
8242       }
8243     }
8244     end_label_40: ;
8245     }
8246 return s;
8247 assert(false);
8248 }
8249 
8250 
simple_name()8251 void VhdlParser::simple_name() {
8252     if (!hasError) {
8253     name();
8254     }
8255 }
8256 
8257 
slice_name()8258 QCString VhdlParser::slice_name() {QCString s,s1;
8259     if (!hasError) {
8260     s = identifier();
8261     }
8262     if (!hasError) {
8263     jj_consume_token(LPAREN_T);
8264     }
8265     if (!hasError) {
8266     s1 = discrete_range();
8267     }
8268     if (!hasError) {
8269     jj_consume_token(RPAREN_T);
8270     }
8271 return s+"("+s1+")";
8272 assert(false);
8273 }
8274 
8275 
string_literal()8276 QCString VhdlParser::string_literal() {Token *tok=0;
8277     if (!hasError) {
8278     tok = jj_consume_token(STRINGLITERAL);
8279     }
8280 return QCString(tok->image);
8281 assert(false);
8282 }
8283 
8284 
subprogram_body()8285 void VhdlParser::subprogram_body() {QCString s;
8286     if (!hasError) {
8287     jj_consume_token(IS_T);
8288     }
8289     if (!hasError) {
8290     //try{
8291      s = subprogram_declarative_part();
8292     }
8293     if (!hasError) {
8294 if (s.data())
8295       {
8296         FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s,QCString());
8297       }
8298       FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",QCString());
8299     }
8300     if (!hasError) {
8301     jj_consume_token(BEGIN_T);
8302     }
8303     if (!hasError) {
8304     subprogram_statement_part();
8305     }
8306     if (!hasError) {
8307     jj_consume_token(END_T);
8308     }
8309     if (!hasError) {
8310     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8311     case FUNCTION_T:
8312     case PROCEDURE_T:{
8313       if (!hasError) {
8314       subprogram_kind();
8315       }
8316       break;
8317       }
8318     default:
8319       jj_la1[216] = jj_gen;
8320       ;
8321     }
8322     }
8323     if (!hasError) {
8324     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8325     case STRINGLITERAL:
8326     case BASIC_IDENTIFIER:
8327     case EXTENDED_CHARACTER:{
8328       if (!hasError) {
8329       designator();
8330       }
8331       break;
8332       }
8333     default:
8334       jj_la1[217] = jj_gen;
8335       ;
8336     }
8337     }
8338     if (!hasError) {
8339     jj_consume_token(SEMI_T);
8340     }
8341 m_sharedState->tempEntry->endBodyLine=outlineParser()->getLine(END_T);
8342       outlineParser()->createFlow();
8343       m_sharedState->currP=0;
8344 }
8345 
8346 
subprogram_declaration()8347 void VhdlParser::subprogram_declaration() {
8348     if (jj_2_100(2147483647)) {
8349       if (!hasError) {
8350       subprogram_instantiation_declaration();
8351       }
8352     } else {
8353       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8354       case FUNCTION_T:
8355       case IMPURE_T:
8356       case PROCEDURE_T:
8357       case PURE_T:{
8358         if (!hasError) {
8359         subprogram_specification();
8360         }
8361         if (!hasError) {
8362         subprogram_1();
8363         }
8364         if (!hasError) {
8365 m_sharedState->currP=0;
8366         }
8367         break;
8368         }
8369       default:
8370         jj_la1[218] = jj_gen;
8371         jj_consume_token(-1);
8372         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8373       }
8374     }
8375 }
8376 
8377 
subprogram_1()8378 void VhdlParser::subprogram_1() {
8379     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8380     case IS_T:{
8381       if (!hasError) {
8382       subprogram_body();
8383       }
8384       break;
8385       }
8386     case SEMI_T:{
8387       if (!hasError) {
8388       jj_consume_token(SEMI_T);
8389       }
8390       break;
8391       }
8392     default:
8393       jj_la1[219] = jj_gen;
8394       jj_consume_token(-1);
8395       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8396     }
8397 }
8398 
8399 
subprogram_declarative_item()8400 QCString VhdlParser::subprogram_declarative_item() {QCString s;
8401     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8402     case FUNCTION_T:
8403     case IMPURE_T:
8404     case PROCEDURE_T:
8405     case PURE_T:{
8406       if (!hasError) {
8407       subprogram_declaration();
8408       }
8409       if (!hasError) {
8410 return QCString();
8411       }
8412       break;
8413       }
8414     case TYPE_T:{
8415       if (!hasError) {
8416       s = type_declaration();
8417       }
8418       if (!hasError) {
8419 return s;
8420       }
8421       break;
8422       }
8423     case IS_T:{
8424       if (!hasError) {
8425       subprogram_body();
8426       }
8427       if (!hasError) {
8428 return QCString();
8429       }
8430       break;
8431       }
8432     case SUBTYPE_T:{
8433       if (!hasError) {
8434       s = subtype_declaration();
8435       }
8436       if (!hasError) {
8437 return s;
8438       }
8439       break;
8440       }
8441     case CONSTANT_T:{
8442       if (!hasError) {
8443       s = constant_declaration();
8444       }
8445       if (!hasError) {
8446 return s;
8447       }
8448       break;
8449       }
8450     case SHARED_T:
8451     case VARIABLE_T:{
8452       if (!hasError) {
8453       s = variable_declaration();
8454       }
8455       if (!hasError) {
8456 return s;
8457       }
8458       break;
8459       }
8460     case FILE_T:{
8461       if (!hasError) {
8462       s = file_declaration();
8463       }
8464       if (!hasError) {
8465 return s;
8466       }
8467       break;
8468       }
8469     case ALIAS_T:{
8470       if (!hasError) {
8471       s = alias_declaration();
8472       }
8473       if (!hasError) {
8474 return s;
8475       }
8476       break;
8477       }
8478     default:
8479       jj_la1[220] = jj_gen;
8480       if (jj_2_101(2147483647)) {
8481         if (!hasError) {
8482         s = attribute_declaration();
8483         }
8484         if (!hasError) {
8485 return s;
8486         }
8487       } else {
8488         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8489         case ATTRIBUTE_T:{
8490           if (!hasError) {
8491           s = attribute_specification();
8492           }
8493           if (!hasError) {
8494 return s;
8495           }
8496           break;
8497           }
8498         case USE_T:{
8499           if (!hasError) {
8500           s = use_clause();
8501           }
8502           if (!hasError) {
8503 return s;
8504           }
8505           break;
8506           }
8507         default:
8508           jj_la1[221] = jj_gen;
8509           if (jj_2_102(3)) {
8510             if (!hasError) {
8511             s = group_template_declaration();
8512             }
8513             if (!hasError) {
8514 return s;
8515             }
8516           } else {
8517             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8518             case GROUP_T:{
8519               if (!hasError) {
8520               s = group_declaration();
8521               }
8522               if (!hasError) {
8523 return s;
8524               }
8525               break;
8526               }
8527             default:
8528               jj_la1[222] = jj_gen;
8529               jj_consume_token(-1);
8530               errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8531             }
8532           }
8533         }
8534       }
8535     }
8536 assert(false);
8537 }
8538 
8539 
subprogram_declarative_part()8540 QCString VhdlParser::subprogram_declarative_part() {QCString s,s1;
8541     if (!hasError) {
8542     while (!hasError) {
8543       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8544       case ALIAS_T:
8545       case ATTRIBUTE_T:
8546       case CONSTANT_T:
8547       case FILE_T:
8548       case FUNCTION_T:
8549       case GROUP_T:
8550       case IMPURE_T:
8551       case IS_T:
8552       case PROCEDURE_T:
8553       case PURE_T:
8554       case SHARED_T:
8555       case SUBTYPE_T:
8556       case TYPE_T:
8557       case USE_T:
8558       case VARIABLE_T:{
8559         ;
8560         break;
8561         }
8562       default:
8563         jj_la1[223] = jj_gen;
8564         goto end_label_41;
8565       }
8566       if (!hasError) {
8567       s1 = subprogram_declarative_item();
8568       }
8569       if (!hasError) {
8570 s+=s1;
8571       }
8572     }
8573     end_label_41: ;
8574     }
8575 return s;
8576 assert(false);
8577 }
8578 
8579 
subprogram_kind()8580 void VhdlParser::subprogram_kind() {
8581     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8582     case FUNCTION_T:{
8583       if (!hasError) {
8584       jj_consume_token(FUNCTION_T);
8585       }
8586       break;
8587       }
8588     case PROCEDURE_T:{
8589       if (!hasError) {
8590       jj_consume_token(PROCEDURE_T);
8591       }
8592       break;
8593       }
8594     default:
8595       jj_la1[224] = jj_gen;
8596       jj_consume_token(-1);
8597       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8598     }
8599 }
8600 
8601 
subprogram_specification()8602 void VhdlParser::subprogram_specification() {QCString s;Token *tok=0;Token *t;
8603     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8604     case PROCEDURE_T:{
8605       if (!hasError) {
8606       jj_consume_token(PROCEDURE_T);
8607       }
8608       if (!hasError) {
8609       s = designator();
8610       }
8611       if (!hasError) {
8612 m_sharedState->currP=VhdlDocGen::PROCEDURE;
8613    outlineParser()->createFunction(s.data(),m_sharedState->currP,0);
8614    m_sharedState->tempEntry=m_sharedState->current;
8615    m_sharedState->current->startLine=outlineParser()->getLine(PROCEDURE_T);
8616    m_sharedState->current->bodyLine=outlineParser()->getLine(PROCEDURE_T);
8617       }
8618       if (!hasError) {
8619       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8620       case LPAREN_T:{
8621         if (!hasError) {
8622         jj_consume_token(LPAREN_T);
8623         }
8624         if (!hasError) {
8625 m_sharedState->param_sec=PARAM_SEC;
8626         }
8627         if (!hasError) {
8628         interface_list();
8629         }
8630         if (!hasError) {
8631 m_sharedState->param_sec=0;
8632         }
8633         if (!hasError) {
8634         jj_consume_token(RPAREN_T);
8635         }
8636         break;
8637         }
8638       default:
8639         jj_la1[225] = jj_gen;
8640         ;
8641       }
8642       }
8643       if (!hasError) {
8644       if (jj_2_103(2)) {
8645         if (!hasError) {
8646         gen_interface_list();
8647         }
8648       } else {
8649         ;
8650       }
8651       }
8652       if (!hasError) {
8653       if (jj_2_104(2)) {
8654         if (!hasError) {
8655         gen_assoc_list();
8656         }
8657       } else {
8658         ;
8659       }
8660       }
8661       if (!hasError) {
8662       param();
8663       }
8664       if (!hasError) {
8665 outlineParser()->newEntry();
8666       }
8667       break;
8668       }
8669     case FUNCTION_T:
8670     case IMPURE_T:
8671     case PURE_T:{
8672       if (!hasError) {
8673       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8674       case IMPURE_T:
8675       case PURE_T:{
8676         if (!hasError) {
8677         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8678         case PURE_T:{
8679           if (!hasError) {
8680           tok = jj_consume_token(PURE_T);
8681           }
8682           break;
8683           }
8684         case IMPURE_T:{
8685           if (!hasError) {
8686           tok = jj_consume_token(IMPURE_T);
8687           }
8688           break;
8689           }
8690         default:
8691           jj_la1[226] = jj_gen;
8692           jj_consume_token(-1);
8693           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8694         }
8695         }
8696         break;
8697         }
8698       default:
8699         jj_la1[227] = jj_gen;
8700         ;
8701       }
8702       }
8703       if (!hasError) {
8704       t = jj_consume_token(FUNCTION_T);
8705       }
8706       if (!hasError) {
8707       s = designator();
8708       }
8709       if (!hasError) {
8710 m_sharedState->currP=VhdlDocGen::FUNCTION;
8711    if(tok)
8712      outlineParser()->createFunction(tok->image.c_str(),m_sharedState->currP,s.data());
8713    else
8714      outlineParser()->createFunction(0,m_sharedState->currP,s.data());
8715    m_sharedState->tempEntry=m_sharedState->current;
8716    m_sharedState->current->startLine=outlineParser()->getLine(FUNCTION_T);
8717    m_sharedState->current->bodyLine=outlineParser()->getLine(FUNCTION_T);
8718       }
8719       if (!hasError) {
8720       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8721       case LPAREN_T:{
8722         if (!hasError) {
8723 m_sharedState->param_sec=PARAM_SEC;
8724         }
8725         if (!hasError) {
8726         jj_consume_token(LPAREN_T);
8727         }
8728         if (!hasError) {
8729         formal_parameter_list();
8730         }
8731         if (!hasError) {
8732         jj_consume_token(RPAREN_T);
8733         }
8734         if (!hasError) {
8735 m_sharedState->param_sec=0;
8736         }
8737         break;
8738         }
8739       default:
8740         jj_la1[228] = jj_gen;
8741         ;
8742       }
8743       }
8744       if (!hasError) {
8745       jj_consume_token(RETURN_T);
8746       }
8747       if (!hasError) {
8748       s = type_mark();
8749       }
8750       if (!hasError) {
8751 m_sharedState->tempEntry=m_sharedState->current;
8752                 m_sharedState->current->type=s;
8753                 outlineParser()->newEntry();
8754       }
8755       break;
8756       }
8757     default:
8758       jj_la1[229] = jj_gen;
8759       jj_consume_token(-1);
8760       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8761     }
8762 }
8763 
8764 
subprogram_statement_part()8765 void VhdlParser::subprogram_statement_part() {
8766     if (!hasError) {
8767     while (!hasError) {
8768       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8769       case ASSERT_T:
8770       case CASE_T:
8771       case EXIT_T:
8772       case FOR_T:
8773       case IF_T:
8774       case LOOP_T:
8775       case NEXT_T:
8776       case NULL_T:
8777       case REPORT_T:
8778       case RETURN_T:
8779       case WAIT_T:
8780       case WHILE_T:
8781       case WITH_T:
8782       case LPAREN_T:
8783       case SLSL_T:
8784       case STRINGLITERAL:
8785       case BASIC_IDENTIFIER:
8786       case EXTENDED_CHARACTER:{
8787         ;
8788         break;
8789         }
8790       default:
8791         jj_la1[230] = jj_gen;
8792         goto end_label_42;
8793       }
8794       if (!hasError) {
8795       sequential_statement();
8796       }
8797     }
8798     end_label_42: ;
8799     }
8800 }
8801 
8802 
subtype_declaration()8803 QCString VhdlParser::subtype_declaration() {QCString s,s1;
8804     if (!hasError) {
8805     jj_consume_token(SUBTYPE_T);
8806     }
8807     if (!hasError) {
8808     s = identifier();
8809     }
8810     if (!hasError) {
8811     jj_consume_token(IS_T);
8812     }
8813     if (!hasError) {
8814     s1 = subtype_indication();
8815     }
8816     if (!hasError) {
8817     jj_consume_token(SEMI_T);
8818     }
8819 outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
8820   return " subtype "+s+" is "+s1+";";
8821 assert(false);
8822 }
8823 
8824 
reslution_indication()8825 QCString VhdlParser::reslution_indication() {QCString s;
8826     if (!hasError) {
8827     jj_consume_token(LPAREN_T);
8828     }
8829     if (!hasError) {
8830     s = expression();
8831     }
8832     if (!hasError) {
8833     jj_consume_token(RPAREN_T);
8834     }
8835 return "("+s+")";
8836 assert(false);
8837 }
8838 
8839 
subtype_indication()8840 QCString VhdlParser::subtype_indication() {QCString s,s1,s2;
8841     if (!hasError) {
8842     if (jj_2_105(5)) {
8843       if (!hasError) {
8844       s = reslution_indication();
8845       }
8846     } else {
8847       ;
8848     }
8849     }
8850     if (!hasError) {
8851     while (!hasError) {
8852       if (!hasError) {
8853       s1 = name();
8854       }
8855       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8856       case SLSL_T:
8857       case STRINGLITERAL:
8858       case BASIC_IDENTIFIER:
8859       case EXTENDED_CHARACTER:{
8860         ;
8861         break;
8862         }
8863       default:
8864         jj_la1[231] = jj_gen;
8865         goto end_label_43;
8866       }
8867     }
8868     end_label_43: ;
8869     }
8870     if (!hasError) {
8871     if (jj_2_106(2147483647)) {
8872       if (!hasError) {
8873       s2 = constraint();
8874       }
8875     } else {
8876       ;
8877     }
8878     }
8879 return s+" "+s1+" "+s2;
8880 assert(false);
8881 }
8882 
8883 
suffix()8884 QCString VhdlParser::suffix() {QCString s;
8885     if (jj_2_107(2147483647)) {
8886       if (!hasError) {
8887       s = name();
8888       }
8889       if (!hasError) {
8890 return s;
8891       }
8892     } else {
8893       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8894       case CHARACTER_LITERAL:{
8895         if (!hasError) {
8896         s = character_literal();
8897         }
8898         if (!hasError) {
8899 return s;
8900         }
8901         break;
8902         }
8903       case STRINGLITERAL:{
8904         if (!hasError) {
8905         s = operator_symbol();
8906         }
8907         if (!hasError) {
8908 return s;
8909         }
8910         break;
8911         }
8912       case ALL_T:{
8913         if (!hasError) {
8914         jj_consume_token(ALL_T);
8915         }
8916         if (!hasError) {
8917 return " all ";
8918         }
8919         break;
8920         }
8921       default:
8922         jj_la1[232] = jj_gen;
8923         jj_consume_token(-1);
8924         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8925       }
8926     }
8927 assert(false);
8928 }
8929 
8930 
target()8931 QCString VhdlParser::target() {QCString s;
8932     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
8933     case SLSL_T:
8934     case STRINGLITERAL:
8935     case BASIC_IDENTIFIER:
8936     case EXTENDED_CHARACTER:{
8937       if (!hasError) {
8938       s = name();
8939       }
8940       if (!hasError) {
8941 return s;
8942       }
8943       break;
8944       }
8945     case LPAREN_T:{
8946       if (!hasError) {
8947       s = aggregate();
8948       }
8949       if (!hasError) {
8950 return s;
8951       }
8952       break;
8953       }
8954     default:
8955       jj_la1[233] = jj_gen;
8956       jj_consume_token(-1);
8957       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
8958     }
8959 assert(false);
8960 }
8961 
8962 
term()8963 QCString VhdlParser::term() {QCString s,s1,s2;
8964     if (!hasError) {
8965     s = factor();
8966     }
8967     if (!hasError) {
8968     while (!hasError) {
8969       if (jj_2_108(2)) {
8970         ;
8971       } else {
8972         goto end_label_44;
8973       }
8974       if (!hasError) {
8975       s1 = multiplying_operation();
8976       }
8977       if (!hasError) {
8978       s2 = factor();
8979       }
8980       if (!hasError) {
8981 s+=s1;s+=s2;
8982       }
8983     }
8984     end_label_44: ;
8985     }
8986 return s;
8987 assert(false);
8988 }
8989 
8990 
timeout_clause()8991 QCString VhdlParser::timeout_clause() {QCString s;
8992     if (!hasError) {
8993     jj_consume_token(FOR_T);
8994     }
8995     if (!hasError) {
8996     s = expression();
8997     }
8998 return " for "+s;
8999 assert(false);
9000 }
9001 
9002 
type_conversion()9003 QCString VhdlParser::type_conversion() {QCString s,s1;
9004     if (!hasError) {
9005     s = name();
9006     }
9007     if (!hasError) {
9008     jj_consume_token(LPAREN_T);
9009     }
9010     if (!hasError) {
9011     s1 = expression();
9012     }
9013     if (!hasError) {
9014     jj_consume_token(RPAREN_T);
9015     }
9016 return s+"("+s1+")";
9017 assert(false);
9018 }
9019 
9020 
type_declaration()9021 QCString VhdlParser::type_declaration() {QCString s;
9022     if (jj_2_109(3)) {
9023       if (!hasError) {
9024       s = full_type_declaration();
9025       }
9026       if (!hasError) {
9027 return s;
9028       }
9029     } else {
9030       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9031       case TYPE_T:{
9032         if (!hasError) {
9033         s = incomplete_type_declaration();
9034         }
9035         if (!hasError) {
9036 return s;
9037         }
9038         break;
9039         }
9040       default:
9041         jj_la1[234] = jj_gen;
9042         jj_consume_token(-1);
9043         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9044       }
9045     }
9046 assert(false);
9047 }
9048 
9049 
type_definition()9050 QCString VhdlParser::type_definition() {QCString s;
9051     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9052     case RANGE_T:
9053     case LPAREN_T:{
9054       if (!hasError) {
9055       s = scalar_type_definition();
9056       }
9057       if (!hasError) {
9058 return s;
9059       }
9060       break;
9061       }
9062     case ARRAY_T:
9063     case RECORD_T:{
9064       if (!hasError) {
9065       s = composite_type_definition();
9066       }
9067       if (!hasError) {
9068 return s;
9069       }
9070       break;
9071       }
9072     case ACCESS_T:{
9073       if (!hasError) {
9074       s = access_type_definition();
9075       }
9076       if (!hasError) {
9077 return s;
9078       }
9079       break;
9080       }
9081     case FILE_T:{
9082       if (!hasError) {
9083       s = file_type_definition();
9084       }
9085       if (!hasError) {
9086 return s;
9087       }
9088       break;
9089       }
9090     default:
9091       jj_la1[235] = jj_gen;
9092       if (jj_2_110(2)) {
9093         if (!hasError) {
9094         protected_type_body();
9095         }
9096         if (!hasError) {
9097 return QCString();
9098         }
9099       } else {
9100         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9101         case PROTECTED_T:{
9102           if (!hasError) {
9103           protected_type_declaration();
9104           }
9105           if (!hasError) {
9106 return QCString();
9107           }
9108           break;
9109           }
9110         default:
9111           jj_la1[236] = jj_gen;
9112           jj_consume_token(-1);
9113           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9114         }
9115       }
9116     }
9117 assert(false);
9118 }
9119 
9120 
type_mark()9121 QCString VhdlParser::type_mark() {QCString s;
9122     if (!hasError) {
9123     s = name();
9124     }
9125 return s;
9126 assert(false);
9127 }
9128 
9129 
unconstraint_array_definition()9130 QCString VhdlParser::unconstraint_array_definition() {QCString s,s1,s2,s3;
9131     if (!hasError) {
9132     jj_consume_token(ARRAY_T);
9133     }
9134     if (!hasError) {
9135     jj_consume_token(LPAREN_T);
9136     }
9137     if (!hasError) {
9138     s = index_subtype_definition();
9139     }
9140     if (!hasError) {
9141     while (!hasError) {
9142       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9143       case COMMA_T:{
9144         ;
9145         break;
9146         }
9147       default:
9148         jj_la1[237] = jj_gen;
9149         goto end_label_45;
9150       }
9151       if (!hasError) {
9152       jj_consume_token(COMMA_T);
9153       }
9154       if (!hasError) {
9155       s1 = index_subtype_definition();
9156       }
9157       if (!hasError) {
9158 s3+=",";s3+=s1;
9159       }
9160     }
9161     end_label_45: ;
9162     }
9163     if (!hasError) {
9164     jj_consume_token(RPAREN_T);
9165     }
9166     if (!hasError) {
9167     jj_consume_token(OF_T);
9168     }
9169     if (!hasError) {
9170     s2 = subtype_indication();
9171     }
9172 return "array("+s+s3+") of "+s2;
9173 assert(false);
9174 }
9175 
9176 
use_clause()9177 QCString VhdlParser::use_clause() {QCString s,s1;
9178     if (!hasError) {
9179     jj_consume_token(USE_T);
9180     }
9181     if (!hasError) {
9182     s = selected_name();
9183     }
9184     if (!hasError) {
9185     while (!hasError) {
9186       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9187       case COMMA_T:{
9188         ;
9189         break;
9190         }
9191       default:
9192         jj_la1[238] = jj_gen;
9193         goto end_label_46;
9194       }
9195       if (!hasError) {
9196       jj_consume_token(COMMA_T);
9197       }
9198       if (!hasError) {
9199       s1 = selected_name();
9200       }
9201       if (!hasError) {
9202 s+=",";s+=s1;
9203       }
9204     }
9205     end_label_46: ;
9206     }
9207     if (!hasError) {
9208     jj_consume_token(SEMI_T);
9209     }
9210 auto ql1=split(s.str(),",");
9211                    for (const auto &name : ql1)
9212                    {
9213                      auto ql2=split(name,".");
9214                      if (ql2.size()>1)
9215                      {
9216                        std::string it=ql2[1];
9217                        if ( m_sharedState->parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
9218                        {
9219                          outlineParser()->addVhdlType(it.c_str(),
9220                                                       outlineParser()->getLine(),
9221                                                       Entry::VARIABLE_SEC,
9222                                                       VhdlDocGen::USE,
9223                                                       it.c_str(),
9224                                                       "_use_",Public);
9225                        }
9226                      }
9227                    }
9228                    s1="use "+s;
9229                    return s1;
9230 assert(false);
9231 }
9232 
9233 
variable_assignment_statement()9234 QCString VhdlParser::variable_assignment_statement() {QCString s,s1,s2;
9235     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9236     case LPAREN_T:
9237     case SLSL_T:
9238     case STRINGLITERAL:
9239     case BASIC_IDENTIFIER:
9240     case EXTENDED_CHARACTER:{
9241       if (!hasError) {
9242       if (jj_2_111(2)) {
9243         if (!hasError) {
9244         s = identifier();
9245         }
9246         if (!hasError) {
9247         jj_consume_token(COLON_T);
9248         }
9249         if (!hasError) {
9250 s+=":";
9251         }
9252       } else {
9253         ;
9254       }
9255       }
9256       if (!hasError) {
9257       s1 = target();
9258       }
9259       if (!hasError) {
9260       jj_consume_token(VARASSIGN_T);
9261       }
9262       if (!hasError) {
9263       s2 = expression();
9264       }
9265       if (!hasError) {
9266       jj_consume_token(SEMI_T);
9267       }
9268       if (!hasError) {
9269 return s+s1+":="+s2+";";
9270       }
9271       break;
9272       }
9273     case WITH_T:{
9274       if (!hasError) {
9275       selected_variable_assignment();
9276       }
9277       if (!hasError) {
9278 return QCString();
9279       }
9280       break;
9281       }
9282     default:
9283       jj_la1[239] = jj_gen;
9284       jj_consume_token(-1);
9285       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9286     }
9287 assert(false);
9288 }
9289 
9290 
variable_declaration()9291 QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s,s1,s2;
9292     if (!hasError) {
9293     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9294     case SHARED_T:{
9295       if (!hasError) {
9296       tok = jj_consume_token(SHARED_T);
9297       }
9298       break;
9299       }
9300     default:
9301       jj_la1[240] = jj_gen;
9302       ;
9303     }
9304     }
9305     if (!hasError) {
9306     jj_consume_token(VARIABLE_T);
9307     }
9308     if (!hasError) {
9309     s = identifier_list();
9310     }
9311     if (!hasError) {
9312     jj_consume_token(COLON_T);
9313     }
9314     if (!hasError) {
9315     s1 = subtype_indication();
9316     }
9317     if (!hasError) {
9318     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9319     case VARASSIGN_T:{
9320       if (!hasError) {
9321       t1 = jj_consume_token(VARASSIGN_T);
9322       }
9323       if (!hasError) {
9324       s2 = expression();
9325       }
9326       break;
9327       }
9328     default:
9329       jj_la1[241] = jj_gen;
9330       ;
9331     }
9332     }
9333     if (!hasError) {
9334     jj_consume_token(SEMI_T);
9335     }
9336 int spec;
9337   if(t1)
9338     s2.prepend(":=");
9339   QCString val=" variable "+s+":"+s1+s2+";";
9340   QCString it=s1;
9341   if(tok != 0)
9342   {
9343     it.prepend(" shared ");
9344     val.prepend(" shared");
9345     spec=VhdlDocGen::SHAREDVARIABLE;
9346   }
9347   else
9348     spec=VhdlDocGen::SHAREDVARIABLE;
9349 
9350   if(t1)
9351   {
9352     it+=":=";
9353     it+=s2;
9354   }
9355   outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
9356   return val;
9357 assert(false);
9358 }
9359 
9360 
wait_statement()9361 QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
9362     if (!hasError) {
9363     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9364     case BASIC_IDENTIFIER:
9365     case EXTENDED_CHARACTER:{
9366       if (!hasError) {
9367       s = identifier();
9368       }
9369       if (!hasError) {
9370       t = jj_consume_token(COLON_T);
9371       }
9372       break;
9373       }
9374     default:
9375       jj_la1[242] = jj_gen;
9376       ;
9377     }
9378     }
9379     if (!hasError) {
9380     jj_consume_token(WAIT_T);
9381     }
9382     if (!hasError) {
9383     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9384     case ON_T:{
9385       if (!hasError) {
9386       s1 = sensitivity_clause();
9387       }
9388       break;
9389       }
9390     default:
9391       jj_la1[243] = jj_gen;
9392       ;
9393     }
9394     }
9395     if (!hasError) {
9396     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9397     case UNTIL_T:{
9398       if (!hasError) {
9399       s2 = condition_clause();
9400       }
9401       break;
9402       }
9403     default:
9404       jj_la1[244] = jj_gen;
9405       ;
9406     }
9407     }
9408     if (!hasError) {
9409     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9410     case FOR_T:{
9411       if (!hasError) {
9412       s3 = timeout_clause();
9413       }
9414       break;
9415       }
9416     default:
9417       jj_la1[245] = jj_gen;
9418       ;
9419     }
9420     }
9421     if (!hasError) {
9422     jj_consume_token(SEMI_T);
9423     }
9424 if(t) s.append(":");
9425   return s+" wait "+s1+s2+s3+";";
9426 assert(false);
9427 }
9428 
9429 
waveform()9430 QCString VhdlParser::waveform() {QCString s,s1;
9431     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9432     case ABS_T:
9433     case AND_T:
9434     case NAND_T:
9435     case NEW_T:
9436     case NOR_T:
9437     case NOT_T:
9438     case NULL_T:
9439     case OR_T:
9440     case XOR_T:
9441     case XNOR_T:
9442     case LPAREN_T:
9443     case PLUS_T:
9444     case MINUS_T:
9445     case SLSL_T:
9446     case QQ_T:
9447     case INTEGER:
9448     case STRINGLITERAL:
9449     case BASIC_IDENTIFIER:
9450     case EXTENDED_CHARACTER:
9451     case CHARACTER_LITERAL:
9452     case DECIMAL_LITERAL:
9453     case BASED_LITERAL:
9454     case BIT_STRING_LITERAL:{
9455       if (!hasError) {
9456       s = waveform_element();
9457       }
9458       if (!hasError) {
9459       while (!hasError) {
9460         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9461         case COMMA_T:{
9462           ;
9463           break;
9464           }
9465         default:
9466           jj_la1[246] = jj_gen;
9467           goto end_label_47;
9468         }
9469         if (!hasError) {
9470         jj_consume_token(COMMA_T);
9471         }
9472         if (!hasError) {
9473         s1 = waveform_element();
9474         }
9475         if (!hasError) {
9476 s+=","; s+=s1;
9477         }
9478       }
9479       end_label_47: ;
9480       }
9481       if (!hasError) {
9482 return s;
9483       }
9484       break;
9485       }
9486     case UNAFFECTED_T:{
9487       if (!hasError) {
9488       jj_consume_token(UNAFFECTED_T);
9489       }
9490       if (!hasError) {
9491 return " unaffected ";
9492       }
9493       break;
9494       }
9495     default:
9496       jj_la1[247] = jj_gen;
9497       jj_consume_token(-1);
9498       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9499     }
9500 assert(false);
9501 }
9502 
9503 
waveform_element()9504 QCString VhdlParser::waveform_element() {QCString s,s1;
9505     if (!hasError) {
9506     s = expression();
9507     }
9508     if (!hasError) {
9509     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9510     case AFTER_T:{
9511       if (!hasError) {
9512       jj_consume_token(AFTER_T);
9513       }
9514       if (!hasError) {
9515       s1 = expression();
9516       }
9517       if (!hasError) {
9518 s1.prepend(" after ");
9519       }
9520       break;
9521       }
9522     default:
9523       jj_la1[248] = jj_gen;
9524       ;
9525     }
9526     }
9527 return s+s1;
9528 assert(false);
9529 }
9530 
9531 
protected_type_body()9532 QCString VhdlParser::protected_type_body() {
9533     if (!hasError) {
9534     jj_consume_token(PROTECTED_T);
9535     }
9536     if (!hasError) {
9537     jj_consume_token(BODY_T);
9538     }
9539     if (!hasError) {
9540     protected_type_body_declarative_part();
9541     }
9542     if (!hasError) {
9543     jj_consume_token(END_T);
9544     }
9545     if (!hasError) {
9546     jj_consume_token(PROTECTED_T);
9547     }
9548     if (!hasError) {
9549     jj_consume_token(BODY_T);
9550     }
9551     if (!hasError) {
9552     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9553     case BASIC_IDENTIFIER:
9554     case EXTENDED_CHARACTER:{
9555       if (!hasError) {
9556       identifier();
9557       }
9558       break;
9559       }
9560     default:
9561       jj_la1[249] = jj_gen;
9562       ;
9563     }
9564     }
9565 return QCString();
9566 assert(false);
9567 }
9568 
9569 
protected_type_body_declarative_item()9570 void VhdlParser::protected_type_body_declarative_item() {
9571     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9572     case FUNCTION_T:
9573     case IMPURE_T:
9574     case PROCEDURE_T:
9575     case PURE_T:{
9576       if (!hasError) {
9577       subprogram_declaration();
9578       }
9579       break;
9580       }
9581     case IS_T:{
9582       if (!hasError) {
9583       subprogram_body();
9584       }
9585       break;
9586       }
9587     case TYPE_T:{
9588       if (!hasError) {
9589       type_declaration();
9590       }
9591       break;
9592       }
9593     case SUBTYPE_T:{
9594       if (!hasError) {
9595       subtype_declaration();
9596       }
9597       break;
9598       }
9599     case CONSTANT_T:{
9600       if (!hasError) {
9601       constant_declaration();
9602       }
9603       break;
9604       }
9605     case SHARED_T:
9606     case VARIABLE_T:{
9607       if (!hasError) {
9608       variable_declaration();
9609       }
9610       break;
9611       }
9612     case FILE_T:{
9613       if (!hasError) {
9614       file_declaration();
9615       }
9616       break;
9617       }
9618     case ALIAS_T:{
9619       if (!hasError) {
9620       alias_declaration();
9621       }
9622       break;
9623       }
9624     default:
9625       jj_la1[250] = jj_gen;
9626       if (jj_2_112(2147483647)) {
9627         if (!hasError) {
9628         attribute_declaration();
9629         }
9630       } else {
9631         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9632         case ATTRIBUTE_T:{
9633           if (!hasError) {
9634           attribute_specification();
9635           }
9636           break;
9637           }
9638         case USE_T:{
9639           if (!hasError) {
9640           use_clause();
9641           }
9642           break;
9643           }
9644         default:
9645           jj_la1[251] = jj_gen;
9646           if (jj_2_113(3)) {
9647             if (!hasError) {
9648             group_template_declaration();
9649             }
9650           } else {
9651             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9652             case GROUP_T:{
9653               if (!hasError) {
9654               group_declaration();
9655               }
9656               break;
9657               }
9658             default:
9659               jj_la1[252] = jj_gen;
9660               jj_consume_token(-1);
9661               errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9662             }
9663           }
9664         }
9665       }
9666     }
9667 }
9668 
9669 
protected_type_body_declarative_part()9670 void VhdlParser::protected_type_body_declarative_part() {
9671     if (!hasError) {
9672     while (!hasError) {
9673       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9674       case ALIAS_T:
9675       case ATTRIBUTE_T:
9676       case CONSTANT_T:
9677       case FILE_T:
9678       case FUNCTION_T:
9679       case GROUP_T:
9680       case IMPURE_T:
9681       case IS_T:
9682       case PROCEDURE_T:
9683       case PURE_T:
9684       case SHARED_T:
9685       case SUBTYPE_T:
9686       case TYPE_T:
9687       case USE_T:
9688       case VARIABLE_T:{
9689         ;
9690         break;
9691         }
9692       default:
9693         jj_la1[253] = jj_gen;
9694         goto end_label_48;
9695       }
9696       if (!hasError) {
9697       protected_type_body_declarative_item();
9698       }
9699     }
9700     end_label_48: ;
9701     }
9702 }
9703 
9704 
protected_type_declaration()9705 QCString VhdlParser::protected_type_declaration() {
9706     if (!hasError) {
9707     jj_consume_token(PROTECTED_T);
9708     }
9709     if (!hasError) {
9710     try {
9711       if (!hasError) {
9712       protected_type_declarative_part();
9713       }
9714     } catch ( ...) {
9715 outlineParser()->error_skipto(END_T);
9716     }
9717     }
9718     if (!hasError) {
9719     jj_consume_token(END_T);
9720     }
9721     if (!hasError) {
9722     jj_consume_token(PROTECTED_T);
9723     }
9724     if (!hasError) {
9725     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9726     case BASIC_IDENTIFIER:
9727     case EXTENDED_CHARACTER:{
9728       if (!hasError) {
9729       identifier();
9730       }
9731       break;
9732       }
9733     default:
9734       jj_la1[254] = jj_gen;
9735       ;
9736     }
9737     }
9738 return QCString();
9739 assert(false);
9740 }
9741 
9742 
protected_type_declarative_item()9743 void VhdlParser::protected_type_declarative_item() {
9744     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9745     case FUNCTION_T:
9746     case IMPURE_T:
9747     case PROCEDURE_T:
9748     case PURE_T:{
9749       if (!hasError) {
9750       subprogram_specification();
9751       }
9752       break;
9753       }
9754     case ATTRIBUTE_T:{
9755       if (!hasError) {
9756       attribute_specification();
9757       }
9758       break;
9759       }
9760     case USE_T:{
9761       if (!hasError) {
9762       use_clause();
9763       }
9764       break;
9765       }
9766     default:
9767       jj_la1[255] = jj_gen;
9768       jj_consume_token(-1);
9769       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9770     }
9771 }
9772 
9773 
protected_type_declarative_part()9774 void VhdlParser::protected_type_declarative_part() {
9775     if (!hasError) {
9776     while (!hasError) {
9777       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9778       case ATTRIBUTE_T:
9779       case FUNCTION_T:
9780       case IMPURE_T:
9781       case PROCEDURE_T:
9782       case PURE_T:
9783       case USE_T:{
9784         ;
9785         break;
9786         }
9787       default:
9788         jj_la1[256] = jj_gen;
9789         goto end_label_49;
9790       }
9791       if (!hasError) {
9792       protected_type_declarative_item();
9793       }
9794       if (!hasError) {
9795       jj_consume_token(SEMI_T);
9796       }
9797     }
9798     end_label_49: ;
9799     }
9800 }
9801 
9802 
context_ref()9803 QCString VhdlParser::context_ref() {QCString s, s1;
9804     if (!hasError) {
9805     jj_consume_token(CONTEXT_T);
9806     }
9807     if (!hasError) {
9808     s = identifier();
9809     }
9810     if (!hasError) {
9811     while (!hasError) {
9812       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9813       case DOT_T:{
9814         ;
9815         break;
9816         }
9817       default:
9818         jj_la1[257] = jj_gen;
9819         goto end_label_50;
9820       }
9821       if (!hasError) {
9822       jj_consume_token(DOT_T);
9823       }
9824       if (!hasError) {
9825       s1 = identifier();
9826       }
9827       if (!hasError) {
9828 s+=".";s+=s1;
9829       }
9830     }
9831     end_label_50: ;
9832     }
9833     if (!hasError) {
9834     jj_consume_token(SEMI_T);
9835     }
9836 return "context "+s ;
9837 assert(false);
9838 }
9839 
9840 
context_declaration()9841 void VhdlParser::context_declaration() {QCString s,s1;
9842     if (!hasError) {
9843     jj_consume_token(CONTEXT_T);
9844     }
9845     if (!hasError) {
9846     s = identifier();
9847     }
9848     if (!hasError) {
9849     jj_consume_token(IS_T);
9850     }
9851     if (!hasError) {
9852 m_sharedState->parse_sec=CONTEXT_SEC;
9853     }
9854     if (!hasError) {
9855     while (!hasError) {
9856       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9857       case CONTEXT_T:
9858       case LIBRARY_T:
9859       case USE_T:{
9860         ;
9861         break;
9862         }
9863       default:
9864         jj_la1[258] = jj_gen;
9865         goto end_label_51;
9866       }
9867       if (!hasError) {
9868       s1 = libustcont_stats();
9869       }
9870     }
9871     end_label_51: ;
9872     }
9873     if (!hasError) {
9874     jj_consume_token(END_T);
9875     }
9876     if (!hasError) {
9877     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9878     case CONTEXT_T:{
9879       if (!hasError) {
9880       jj_consume_token(CONTEXT_T);
9881       }
9882       break;
9883       }
9884     default:
9885       jj_la1[259] = jj_gen;
9886       ;
9887     }
9888     }
9889     if (!hasError) {
9890     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9891     case BASIC_IDENTIFIER:
9892     case EXTENDED_CHARACTER:{
9893       if (!hasError) {
9894       identifier();
9895       }
9896       break;
9897       }
9898     default:
9899       jj_la1[260] = jj_gen;
9900       ;
9901     }
9902     }
9903     if (!hasError) {
9904     jj_consume_token(SEMI_T);
9905     }
9906 m_sharedState->parse_sec=0;
9907                           outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
9908 }
9909 
9910 
libustcont_stats()9911 QCString VhdlParser::libustcont_stats() {QCString s;
9912     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9913     case USE_T:{
9914       if (!hasError) {
9915       s = use_clause();
9916       }
9917       if (!hasError) {
9918 return s;
9919       }
9920       break;
9921       }
9922     case LIBRARY_T:{
9923       if (!hasError) {
9924       s = library_clause();
9925       }
9926       if (!hasError) {
9927 return s;
9928       }
9929       break;
9930       }
9931     case CONTEXT_T:{
9932       if (!hasError) {
9933       s = context_ref();
9934       }
9935       if (!hasError) {
9936 return s;
9937       }
9938       break;
9939       }
9940     default:
9941       jj_la1[261] = jj_gen;
9942       jj_consume_token(-1);
9943       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
9944     }
9945 assert(false);
9946 }
9947 
9948 
package_instantiation_declaration()9949 void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;
9950     if (!hasError) {
9951     jj_consume_token(PACKAGE_T);
9952     }
9953     if (!hasError) {
9954     s = identifier();
9955     }
9956     if (!hasError) {
9957     jj_consume_token(IS_T);
9958     }
9959     if (!hasError) {
9960     jj_consume_token(NEW_T);
9961     }
9962     if (!hasError) {
9963     s1 = name();
9964     }
9965     if (!hasError) {
9966     s2 = signature();
9967     }
9968     if (!hasError) {
9969     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
9970     case GENERIC_T:{
9971       if (!hasError) {
9972       gen_assoc_list();
9973       }
9974       break;
9975       }
9976     default:
9977       jj_la1[262] = jj_gen;
9978       ;
9979     }
9980     }
9981     if (!hasError) {
9982     jj_consume_token(SEMI_T);
9983     }
9984 QCString q=" is new "+s1+s2;
9985       outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
9986 }
9987 
9988 
interface_package_declaration()9989 QCString VhdlParser::interface_package_declaration() {QCString s,s1;
9990     if (!hasError) {
9991     jj_consume_token(PACKAGE_T);
9992     }
9993     if (!hasError) {
9994     s = identifier();
9995     }
9996     if (!hasError) {
9997     jj_consume_token(IS_T);
9998     }
9999     if (!hasError) {
10000     jj_consume_token(NEW_T);
10001     }
10002     if (!hasError) {
10003     s1 = name();
10004     }
10005     if (!hasError) {
10006     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10007     case GENERIC_T:{
10008       if (!hasError) {
10009       gen_assoc_list();
10010       }
10011       break;
10012       }
10013     default:
10014       jj_la1[263] = jj_gen;
10015       ;
10016     }
10017     }
10018 m_sharedState->current->name=s;
10019                             return "package "+s+" is new "+s1;
10020 assert(false);
10021 }
10022 
10023 
subprogram_instantiation_declaration()10024 QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;
10025     if (!hasError) {
10026     jj_consume_token(FUNCTION_T);
10027     }
10028     if (!hasError) {
10029     s = identifier();
10030     }
10031     if (!hasError) {
10032     jj_consume_token(IS_T);
10033     }
10034     if (!hasError) {
10035     jj_consume_token(NEW_T);
10036     }
10037     if (!hasError) {
10038     s1 = name();
10039     }
10040     if (!hasError) {
10041     s2 = signature();
10042     }
10043     if (!hasError) {
10044     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10045     case GENERIC_T:{
10046       if (!hasError) {
10047       gen_assoc_list();
10048       }
10049       break;
10050       }
10051     default:
10052       jj_la1[264] = jj_gen;
10053       ;
10054     }
10055     }
10056     if (!hasError) {
10057     jj_consume_token(SEMI_T);
10058     }
10059 QCString q= " is new "+s1+s2;
10060       outlineParser()->addVhdlType(s.data(),outlineParser()->getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
10061     return q;
10062 assert(false);
10063 }
10064 
10065 
gen_assoc_list()10066 void VhdlParser::gen_assoc_list() {
10067     if (!hasError) {
10068     jj_consume_token(GENERIC_T);
10069     }
10070     if (!hasError) {
10071     jj_consume_token(MAP_T);
10072     }
10073     if (!hasError) {
10074     jj_consume_token(LPAREN_T);
10075     }
10076     if (!hasError) {
10077     association_list();
10078     }
10079     if (!hasError) {
10080     jj_consume_token(RPAREN_T);
10081     }
10082 }
10083 
10084 
gen_interface_list()10085 void VhdlParser::gen_interface_list() {
10086     if (!hasError) {
10087     jj_consume_token(GENERIC_T);
10088     }
10089     if (!hasError) {
10090     jj_consume_token(LPAREN_T);
10091     }
10092     if (!hasError) {
10093 //int u=s_str.iLine;
10094                           m_sharedState->parse_sec=GEN_SEC;
10095     }
10096     if (!hasError) {
10097     interface_list();
10098     }
10099     if (!hasError) {
10100 //  QCString vo=$3;
10101                           m_sharedState->parse_sec=0;
10102     }
10103     if (!hasError) {
10104     jj_consume_token(RPAREN_T);
10105     }
10106 }
10107 
10108 
case_scheme()10109 void VhdlParser::case_scheme() {
10110     if (!hasError) {
10111     jj_consume_token(CASE_T);
10112     }
10113     if (!hasError) {
10114     expression();
10115     }
10116     if (!hasError) {
10117     jj_consume_token(GENERATE_T);
10118     }
10119     if (!hasError) {
10120     when_stats();
10121     }
10122     if (!hasError) {
10123     if (jj_2_114(3)) {
10124       if (!hasError) {
10125       ttend();
10126       }
10127     } else {
10128       ;
10129     }
10130     }
10131     if (!hasError) {
10132     jj_consume_token(END_T);
10133     }
10134     if (!hasError) {
10135     jj_consume_token(GENERATE_T);
10136     }
10137     if (!hasError) {
10138     generate_statement_body();
10139     }
10140     if (!hasError) {
10141     jj_consume_token(SEMI_T);
10142     }
10143 }
10144 
10145 
when_stats()10146 void VhdlParser::when_stats() {
10147     if (!hasError) {
10148     while (!hasError) {
10149       if (!hasError) {
10150       jj_consume_token(WHEN_T);
10151       }
10152       if (!hasError) {
10153       if (jj_2_115(2)) {
10154         if (!hasError) {
10155         label();
10156         }
10157         if (!hasError) {
10158         jj_consume_token(COLON_T);
10159         }
10160       } else {
10161         ;
10162       }
10163       }
10164       if (!hasError) {
10165       choices();
10166       }
10167       if (!hasError) {
10168       jj_consume_token(ARROW_T);
10169       }
10170       if (!hasError) {
10171       generate_statement_body();
10172       }
10173       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10174       case WHEN_T:{
10175         ;
10176         break;
10177         }
10178       default:
10179         jj_la1[265] = jj_gen;
10180         goto end_label_52;
10181       }
10182     }
10183     end_label_52: ;
10184     }
10185 }
10186 
10187 
ttend()10188 void VhdlParser::ttend() {
10189     if (!hasError) {
10190     jj_consume_token(END_T);
10191     }
10192     if (!hasError) {
10193     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10194     case BASIC_IDENTIFIER:
10195     case EXTENDED_CHARACTER:{
10196       if (!hasError) {
10197       identifier();
10198       }
10199       break;
10200       }
10201     default:
10202       jj_la1[266] = jj_gen;
10203       ;
10204     }
10205     }
10206     if (!hasError) {
10207     jj_consume_token(SEMI_T);
10208     }
10209 }
10210 
10211 
generate_statement_body()10212 void VhdlParser::generate_statement_body() {
10213     if (!hasError) {
10214     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10215     case ALIAS_T:
10216     case ATTRIBUTE_T:
10217     case BEGIN_T:
10218     case COMPONENT_T:
10219     case CONSTANT_T:
10220     case DISCONNECT_T:
10221     case FILE_T:
10222     case FOR_T:
10223     case FUNCTION_T:
10224     case GROUP_T:
10225     case IMPURE_T:
10226     case PROCEDURE_T:
10227     case PURE_T:
10228     case SIGNAL_T:
10229     case SHARED_T:
10230     case SUBTYPE_T:
10231     case TYPE_T:
10232     case USE_T:
10233     case VARIABLE_T:{
10234       if (!hasError) {
10235       while (!hasError) {
10236         if (jj_2_116(2147483647)) {
10237           ;
10238         } else {
10239           goto end_label_53;
10240         }
10241         if (!hasError) {
10242         block_declarative_item();
10243         }
10244       }
10245       end_label_53: ;
10246       }
10247       if (!hasError) {
10248       jj_consume_token(BEGIN_T);
10249       }
10250       break;
10251       }
10252     default:
10253       jj_la1[267] = jj_gen;
10254       ;
10255     }
10256     }
10257     if (!hasError) {
10258     while (!hasError) {
10259       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10260       case ASSERT_T:
10261       case CASE_T:
10262       case POSTPONED_T:
10263       case PROCESS_T:
10264       case WITH_T:
10265       case LPAREN_T:
10266       case SLSL_T:
10267       case STRINGLITERAL:
10268       case BASIC_IDENTIFIER:
10269       case EXTENDED_CHARACTER:
10270       case VHDL2008TOOLDIR:{
10271         ;
10272         break;
10273         }
10274       default:
10275         jj_la1[268] = jj_gen;
10276         goto end_label_54;
10277       }
10278       if (!hasError) {
10279       concurrent_statement();
10280       }
10281     }
10282     end_label_54: ;
10283     }
10284 }
10285 
10286 
generate_statement_body1()10287 void VhdlParser::generate_statement_body1() {
10288     if (!hasError) {
10289     generate_statement_body();
10290     }
10291     if (!hasError) {
10292     generate_scheme_1();
10293     }
10294     if (!hasError) {
10295     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10296     case ELSE_T:{
10297       if (!hasError) {
10298       generate_scheme_2();
10299       }
10300       break;
10301       }
10302     default:
10303       jj_la1[269] = jj_gen;
10304       ;
10305     }
10306     }
10307 }
10308 
10309 
generate_scheme_1()10310 void VhdlParser::generate_scheme_1() {
10311     if (!hasError) {
10312     while (!hasError) {
10313       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10314       case ELSIF_T:{
10315         ;
10316         break;
10317         }
10318       default:
10319         jj_la1[270] = jj_gen;
10320         goto end_label_55;
10321       }
10322       if (!hasError) {
10323       generate_scheme_3();
10324       }
10325     }
10326     end_label_55: ;
10327     }
10328 }
10329 
10330 
generate_scheme_2()10331 void VhdlParser::generate_scheme_2() {
10332     if (!hasError) {
10333     jj_consume_token(ELSE_T);
10334     }
10335     if (!hasError) {
10336     if (jj_2_117(2)) {
10337       if (!hasError) {
10338       identifier();
10339       }
10340       if (!hasError) {
10341       jj_consume_token(COLON_T);
10342       }
10343     } else {
10344       ;
10345     }
10346     }
10347     if (!hasError) {
10348     jj_consume_token(GENERATE_T);
10349     }
10350     if (!hasError) {
10351     generate_statement_body();
10352     }
10353 }
10354 
10355 
generate_scheme_3()10356 void VhdlParser::generate_scheme_3() {
10357     if (!hasError) {
10358     jj_consume_token(ELSIF_T);
10359     }
10360     if (!hasError) {
10361     if (jj_2_118(2)) {
10362       if (!hasError) {
10363       identifier();
10364       }
10365       if (!hasError) {
10366       jj_consume_token(COLON_T);
10367       }
10368     } else {
10369       ;
10370     }
10371     }
10372     if (!hasError) {
10373     expression();
10374     }
10375     if (!hasError) {
10376     jj_consume_token(GENERATE_T);
10377     }
10378     if (!hasError) {
10379     generate_statement_body();
10380     }
10381 }
10382 
10383 
external_name()10384 QCString VhdlParser::external_name() {QCString s,s1,s2;
10385     if (!hasError) {
10386     jj_consume_token(SLSL_T);
10387     }
10388     if (!hasError) {
10389     s = sig_stat();
10390     }
10391     if (!hasError) {
10392     s1 = external_pathname();
10393     }
10394     if (!hasError) {
10395     jj_consume_token(COLON_T);
10396     }
10397     if (!hasError) {
10398     s2 = subtype_indication();
10399     }
10400     if (!hasError) {
10401     jj_consume_token(RSRS_T);
10402     }
10403 QCString t="<<"+s;
10404                          QCString t1=s1+":"+s2+">>";
10405                          return   s+s1;
10406 assert(false);
10407 }
10408 
10409 
sig_stat()10410 QCString VhdlParser::sig_stat() {Token *t;
10411     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10412     case CONSTANT_T:{
10413       if (!hasError) {
10414       t = jj_consume_token(CONSTANT_T);
10415       }
10416       if (!hasError) {
10417 return QCString(t->image);
10418       }
10419       break;
10420       }
10421     case SIGNAL_T:{
10422       if (!hasError) {
10423       t = jj_consume_token(SIGNAL_T);
10424       }
10425       if (!hasError) {
10426 return QCString(t->image);
10427       }
10428       break;
10429       }
10430     case VARIABLE_T:{
10431       if (!hasError) {
10432       t = jj_consume_token(VARIABLE_T);
10433       }
10434       if (!hasError) {
10435 return QCString(t->image);
10436       }
10437       break;
10438       }
10439     default:
10440       jj_la1[271] = jj_gen;
10441       jj_consume_token(-1);
10442       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10443     }
10444 assert(false);
10445 }
10446 
10447 
external_pathname()10448 QCString VhdlParser::external_pathname() {QCString s;
10449     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10450     case DOT_T:{
10451       if (!hasError) {
10452       s = absolute_pathname();
10453       }
10454       if (!hasError) {
10455 return s;
10456       }
10457       break;
10458       }
10459     case NEG_T:{
10460       if (!hasError) {
10461       s = relative_pathname();
10462       }
10463       if (!hasError) {
10464 return s;
10465       }
10466       break;
10467       }
10468     case AT_T:{
10469       if (!hasError) {
10470       s = package_path_name();
10471       }
10472       if (!hasError) {
10473 return s;
10474       }
10475       break;
10476       }
10477     default:
10478       jj_la1[272] = jj_gen;
10479       jj_consume_token(-1);
10480       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10481     }
10482 assert(false);
10483 }
10484 
10485 
absolute_pathname()10486 QCString VhdlParser::absolute_pathname() {QCString s,s1;
10487     if (jj_2_119(2147483647)) {
10488       if (!hasError) {
10489       jj_consume_token(DOT_T);
10490       }
10491       if (!hasError) {
10492       s = pathname_element_list();
10493       }
10494       if (!hasError) {
10495       s1 = identifier();
10496       }
10497       if (!hasError) {
10498 return "."+s+s1;
10499       }
10500     } else {
10501       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10502       case DOT_T:{
10503         if (!hasError) {
10504         jj_consume_token(DOT_T);
10505         }
10506         if (!hasError) {
10507         s = identifier();
10508         }
10509         if (!hasError) {
10510 return "."+s;
10511         }
10512         break;
10513         }
10514       default:
10515         jj_la1[273] = jj_gen;
10516         jj_consume_token(-1);
10517         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10518       }
10519     }
10520 assert(false);
10521 }
10522 
10523 
relative_pathname()10524 QCString VhdlParser::relative_pathname() {QCString s,s1,s2;
10525     if (!hasError) {
10526     s = neg_list();
10527     }
10528     if (!hasError) {
10529     if (jj_2_120(2147483647)) {
10530       if (!hasError) {
10531       s1 = pathname_element_list();
10532       }
10533     } else {
10534       ;
10535     }
10536     }
10537     if (!hasError) {
10538     s2 = identifier();
10539     }
10540 return s+s1+s2;
10541 assert(false);
10542 }
10543 
10544 
neg_list()10545 QCString VhdlParser::neg_list() {QCString s;
10546     if (!hasError) {
10547     while (!hasError) {
10548       if (!hasError) {
10549       jj_consume_token(NEG_T);
10550       }
10551       if (!hasError) {
10552       jj_consume_token(DOT_T);
10553       }
10554       if (!hasError) {
10555 s+="^.";
10556       }
10557       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10558       case NEG_T:{
10559         ;
10560         break;
10561         }
10562       default:
10563         jj_la1[274] = jj_gen;
10564         goto end_label_56;
10565       }
10566     }
10567     end_label_56: ;
10568     }
10569 return s;
10570 assert(false);
10571 }
10572 
10573 
pathname_element()10574 QCString VhdlParser::pathname_element() {QCString s,s1;
10575     if (!hasError) {
10576     s = identifier();
10577     }
10578     if (!hasError) {
10579     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10580     case LPAREN_T:{
10581       if (!hasError) {
10582       jj_consume_token(LPAREN_T);
10583       }
10584       if (!hasError) {
10585       s1 = expression();
10586       }
10587       if (!hasError) {
10588       jj_consume_token(RPAREN_T);
10589       }
10590       break;
10591       }
10592     default:
10593       jj_la1[275] = jj_gen;
10594       ;
10595     }
10596     }
10597 if(!s1.isEmpty())
10598      return s+"("+s1+")";
10599 
10600     return s;
10601 assert(false);
10602 }
10603 
10604 
pathname_element_list()10605 QCString VhdlParser::pathname_element_list() {QCString s,s1,s2;
10606     if (!hasError) {
10607     if (!hasError) {
10608     s = pathname_element();
10609     }
10610     if (!hasError) {
10611     jj_consume_token(DOT_T);
10612     }
10613     }
10614     if (!hasError) {
10615 s+=".";
10616     }
10617     if (!hasError) {
10618     while (!hasError) {
10619       if (jj_2_121(2147483647)) {
10620         ;
10621       } else {
10622         goto end_label_57;
10623       }
10624       if (!hasError) {
10625       s1 = pathname_element();
10626       }
10627       if (!hasError) {
10628       jj_consume_token(DOT_T);
10629       }
10630       if (!hasError) {
10631 s2+=s1;s2+=".";
10632       }
10633     }
10634     end_label_57: ;
10635     }
10636 return s+s2;
10637 assert(false);
10638 }
10639 
10640 
package_path_name()10641 QCString VhdlParser::package_path_name() {QCString s;
10642     if (!hasError) {
10643     jj_consume_token(AT_T);
10644     }
10645     if (!hasError) {
10646     s = name();
10647     }
10648 return "@"+s;
10649 assert(false);
10650 }
10651 
10652 
conditional_signal_assignment_wave()10653 void VhdlParser::conditional_signal_assignment_wave() {
10654     if (jj_2_122(2147483647)) {
10655       if (!hasError) {
10656       conditional_force_assignment();
10657       }
10658     } else {
10659       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10660       case LPAREN_T:
10661       case SLSL_T:
10662       case STRINGLITERAL:
10663       case BASIC_IDENTIFIER:
10664       case EXTENDED_CHARACTER:{
10665         if (!hasError) {
10666         conditional_waveform_assignment();
10667         }
10668         break;
10669         }
10670       default:
10671         jj_la1[276] = jj_gen;
10672         jj_consume_token(-1);
10673         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10674       }
10675     }
10676 }
10677 
10678 
conditional_waveform_assignment()10679 void VhdlParser::conditional_waveform_assignment() {
10680     if (!hasError) {
10681     target();
10682     }
10683     if (!hasError) {
10684     jj_consume_token(LESSTHAN_T);
10685     }
10686     if (!hasError) {
10687     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10688     case INERTIAL_T:
10689     case REJECT_T:
10690     case TRANSPORT_T:{
10691       if (!hasError) {
10692       delay_mechanism();
10693       }
10694       break;
10695       }
10696     default:
10697       jj_la1[277] = jj_gen;
10698       ;
10699     }
10700     }
10701     if (!hasError) {
10702     waveform_element();
10703     }
10704     if (!hasError) {
10705     jj_consume_token(WHEN_T);
10706     }
10707     if (!hasError) {
10708     expression();
10709     }
10710     if (!hasError) {
10711     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10712     case ELSE_T:{
10713       if (!hasError) {
10714       else_wave_list();
10715       }
10716       break;
10717       }
10718     default:
10719       jj_la1[278] = jj_gen;
10720       ;
10721     }
10722     }
10723     if (!hasError) {
10724     jj_consume_token(SEMI_T);
10725     }
10726 }
10727 
10728 
else_wave_list()10729 void VhdlParser::else_wave_list() {
10730     if (!hasError) {
10731     jj_consume_token(ELSE_T);
10732     }
10733     if (!hasError) {
10734     expression();
10735     }
10736     if (!hasError) {
10737     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10738     case WHEN_T:{
10739       if (!hasError) {
10740       jj_consume_token(WHEN_T);
10741       }
10742       if (!hasError) {
10743       expression();
10744       }
10745       break;
10746       }
10747     default:
10748       jj_la1[279] = jj_gen;
10749       ;
10750     }
10751     }
10752 }
10753 
10754 
conditional_force_assignment()10755 void VhdlParser::conditional_force_assignment() {
10756     if (!hasError) {
10757     target();
10758     }
10759     if (!hasError) {
10760     jj_consume_token(LESSTHAN_T);
10761     }
10762     if (!hasError) {
10763     jj_consume_token(FORCE_T);
10764     }
10765     if (!hasError) {
10766     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10767     case IN_T:
10768     case OUT_T:{
10769       if (!hasError) {
10770       inout_stat();
10771       }
10772       break;
10773       }
10774     default:
10775       jj_la1[280] = jj_gen;
10776       ;
10777     }
10778     }
10779     if (!hasError) {
10780     expression();
10781     }
10782     if (!hasError) {
10783     jj_consume_token(WHEN_T);
10784     }
10785     if (!hasError) {
10786     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10787     case ABS_T:
10788     case AND_T:
10789     case NAND_T:
10790     case NEW_T:
10791     case NOR_T:
10792     case NOT_T:
10793     case NULL_T:
10794     case OR_T:
10795     case XOR_T:
10796     case XNOR_T:
10797     case LPAREN_T:
10798     case PLUS_T:
10799     case MINUS_T:
10800     case SLSL_T:
10801     case QQ_T:
10802     case INTEGER:
10803     case STRINGLITERAL:
10804     case BASIC_IDENTIFIER:
10805     case EXTENDED_CHARACTER:
10806     case CHARACTER_LITERAL:
10807     case DECIMAL_LITERAL:
10808     case BASED_LITERAL:
10809     case BIT_STRING_LITERAL:{
10810       if (!hasError) {
10811       expression();
10812       }
10813       if (!hasError) {
10814       else_stat();
10815       }
10816       break;
10817       }
10818     default:
10819       jj_la1[281] = jj_gen;
10820       ;
10821     }
10822     }
10823     if (!hasError) {
10824     jj_consume_token(SEMI_T);
10825     }
10826 }
10827 
10828 
selected_signal_assignment_wave()10829 void VhdlParser::selected_signal_assignment_wave() {
10830     if (jj_2_123(2147483647)) {
10831       if (!hasError) {
10832       selected_force_assignment();
10833       }
10834     } else {
10835       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10836       case WITH_T:{
10837         if (!hasError) {
10838         selected_waveform_assignment();
10839         }
10840         break;
10841         }
10842       default:
10843         jj_la1[282] = jj_gen;
10844         jj_consume_token(-1);
10845         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10846       }
10847     }
10848 }
10849 
10850 
selected_variable_assignment()10851 void VhdlParser::selected_variable_assignment() {
10852     if (!hasError) {
10853     jj_consume_token(WITH_T);
10854     }
10855     if (!hasError) {
10856     expression();
10857     }
10858     if (!hasError) {
10859     jj_consume_token(SELECT_T);
10860     }
10861     if (!hasError) {
10862     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10863     case Q_T:{
10864       if (!hasError) {
10865       jj_consume_token(Q_T);
10866       }
10867       break;
10868       }
10869     default:
10870       jj_la1[283] = jj_gen;
10871       ;
10872     }
10873     }
10874     if (!hasError) {
10875     select_name();
10876     }
10877     if (!hasError) {
10878     jj_consume_token(VARASSIGN_T);
10879     }
10880     if (!hasError) {
10881     sel_var_list();
10882     }
10883 }
10884 
10885 
select_name()10886 void VhdlParser::select_name() {
10887     if (jj_2_124(2147483647)) {
10888       if (!hasError) {
10889       aggregate();
10890       }
10891     } else {
10892       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10893       case SLSL_T:
10894       case STRINGLITERAL:
10895       case BASIC_IDENTIFIER:
10896       case EXTENDED_CHARACTER:{
10897         if (!hasError) {
10898         name();
10899         }
10900         break;
10901         }
10902       default:
10903         jj_la1[284] = jj_gen;
10904         jj_consume_token(-1);
10905         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
10906       }
10907     }
10908 }
10909 
10910 
selected_waveform_assignment()10911 void VhdlParser::selected_waveform_assignment() {
10912     if (!hasError) {
10913     jj_consume_token(WITH_T);
10914     }
10915     if (!hasError) {
10916     expression();
10917     }
10918     if (!hasError) {
10919     jj_consume_token(SELECT_T);
10920     }
10921     if (!hasError) {
10922     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10923     case Q_T:{
10924       if (!hasError) {
10925       jj_consume_token(Q_T);
10926       }
10927       break;
10928       }
10929     default:
10930       jj_la1[285] = jj_gen;
10931       ;
10932     }
10933     }
10934     if (!hasError) {
10935     target();
10936     }
10937     if (!hasError) {
10938     jj_consume_token(LESSTHAN_T);
10939     }
10940     if (!hasError) {
10941     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10942     case INERTIAL_T:
10943     case REJECT_T:
10944     case TRANSPORT_T:{
10945       if (!hasError) {
10946       delay_mechanism();
10947       }
10948       break;
10949       }
10950     default:
10951       jj_la1[286] = jj_gen;
10952       ;
10953     }
10954     }
10955     if (!hasError) {
10956     sel_wave_list();
10957     }
10958 }
10959 
10960 
selected_force_assignment()10961 void VhdlParser::selected_force_assignment() {
10962     if (!hasError) {
10963     jj_consume_token(WITH_T);
10964     }
10965     if (!hasError) {
10966     expression();
10967     }
10968     if (!hasError) {
10969     jj_consume_token(SELECT_T);
10970     }
10971     if (!hasError) {
10972     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10973     case Q_T:{
10974       if (!hasError) {
10975       jj_consume_token(Q_T);
10976       }
10977       break;
10978       }
10979     default:
10980       jj_la1[287] = jj_gen;
10981       ;
10982     }
10983     }
10984     if (!hasError) {
10985     target();
10986     }
10987     if (!hasError) {
10988     jj_consume_token(LESSTHAN_T);
10989     }
10990     if (!hasError) {
10991     jj_consume_token(FORCE_T);
10992     }
10993     if (!hasError) {
10994     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
10995     case IN_T:
10996     case OUT_T:{
10997       if (!hasError) {
10998       inout_stat();
10999       }
11000       break;
11001       }
11002     default:
11003       jj_la1[288] = jj_gen;
11004       ;
11005     }
11006     }
11007     if (!hasError) {
11008     sel_var_list();
11009     }
11010 }
11011 
11012 
sel_var_list()11013 void VhdlParser::sel_var_list() {
11014     if (!hasError) {
11015     if (!hasError) {
11016     expression();
11017     }
11018     if (!hasError) {
11019     jj_consume_token(WHEN_T);
11020     }
11021     if (!hasError) {
11022     choices();
11023     }
11024     if (!hasError) {
11025     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11026     case COMMA_T:{
11027       if (!hasError) {
11028       jj_consume_token(COMMA_T);
11029       }
11030       break;
11031       }
11032     case SEMI_T:{
11033       if (!hasError) {
11034       jj_consume_token(SEMI_T);
11035       }
11036       break;
11037       }
11038     default:
11039       jj_la1[289] = jj_gen;
11040       jj_consume_token(-1);
11041       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11042     }
11043     }
11044     }
11045     if (!hasError) {
11046     while (!hasError) {
11047       if (jj_2_125(2147483647)) {
11048         ;
11049       } else {
11050         goto end_label_58;
11051       }
11052       if (!hasError) {
11053       expression();
11054       }
11055       if (!hasError) {
11056       jj_consume_token(WHEN_T);
11057       }
11058       if (!hasError) {
11059       choices();
11060       }
11061       if (!hasError) {
11062       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11063       case COMMA_T:{
11064         if (!hasError) {
11065         jj_consume_token(COMMA_T);
11066         }
11067         break;
11068         }
11069       case SEMI_T:{
11070         if (!hasError) {
11071         jj_consume_token(SEMI_T);
11072         }
11073         break;
11074         }
11075       default:
11076         jj_la1[290] = jj_gen;
11077         jj_consume_token(-1);
11078         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11079       }
11080       }
11081     }
11082     end_label_58: ;
11083     }
11084 }
11085 
11086 
sel_wave_list()11087 void VhdlParser::sel_wave_list() {
11088     if (!hasError) {
11089     waveform_element();
11090     }
11091     if (!hasError) {
11092     jj_consume_token(WHEN_T);
11093     }
11094     if (!hasError) {
11095     choices();
11096     }
11097     if (!hasError) {
11098     while (!hasError) {
11099       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11100       case COMMA_T:{
11101         ;
11102         break;
11103         }
11104       default:
11105         jj_la1[291] = jj_gen;
11106         goto end_label_59;
11107       }
11108       if (!hasError) {
11109       jj_consume_token(COMMA_T);
11110       }
11111       if (!hasError) {
11112       sel_wave_list();
11113       }
11114     }
11115     end_label_59: ;
11116     }
11117     if (!hasError) {
11118     jj_consume_token(SEMI_T);
11119     }
11120 }
11121 
11122 
inout_stat()11123 void VhdlParser::inout_stat() {
11124     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11125     case IN_T:{
11126       if (!hasError) {
11127       jj_consume_token(IN_T);
11128       }
11129       break;
11130       }
11131     case OUT_T:{
11132       if (!hasError) {
11133       jj_consume_token(OUT_T);
11134       }
11135       break;
11136       }
11137     default:
11138       jj_la1[292] = jj_gen;
11139       jj_consume_token(-1);
11140       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11141     }
11142 }
11143 
11144 
else_stat()11145 void VhdlParser::else_stat() {
11146     if (!hasError) {
11147     while (!hasError) {
11148       if (!hasError) {
11149       jj_consume_token(ELSE_T);
11150       }
11151       if (!hasError) {
11152       expression();
11153       }
11154       if (!hasError) {
11155       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11156       case WHEN_T:{
11157         if (!hasError) {
11158         jj_consume_token(WHEN_T);
11159         }
11160         if (!hasError) {
11161         expression();
11162         }
11163         break;
11164         }
11165       default:
11166         jj_la1[293] = jj_gen;
11167         ;
11168       }
11169       }
11170       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11171       case ELSE_T:{
11172         ;
11173         break;
11174         }
11175       default:
11176         jj_la1[294] = jj_gen;
11177         goto end_label_60;
11178       }
11179     }
11180     end_label_60: ;
11181     }
11182 }
11183 
11184 
interface_subprogram_declaration()11185 QCString VhdlParser::interface_subprogram_declaration() {QCString s;
11186     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11187     case PROCEDURE_T:{
11188       if (!hasError) {
11189       s = iproc();
11190       }
11191       if (!hasError) {
11192 return s;
11193       }
11194       break;
11195       }
11196     case FUNCTION_T:
11197     case IMPURE_T:
11198     case PURE_T:{
11199       if (!hasError) {
11200       s = ifunc();
11201       }
11202       if (!hasError) {
11203 return s;
11204       }
11205       break;
11206       }
11207     default:
11208       jj_la1[295] = jj_gen;
11209       jj_consume_token(-1);
11210       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11211     }
11212 assert(false);
11213 }
11214 
11215 
iproc()11216 QCString VhdlParser::iproc() {QCString s,s1;
11217     if (!hasError) {
11218     jj_consume_token(PROCEDURE_T);
11219     }
11220     if (!hasError) {
11221     s = identifier();
11222     }
11223     if (!hasError) {
11224     s1 = param();
11225     }
11226 m_sharedState->current->name=s;
11227     return "procedure "+s+s1;
11228 assert(false);
11229 }
11230 
11231 
ifunc()11232 QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;
11233     if (!hasError) {
11234     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11235     case IMPURE_T:
11236     case PURE_T:{
11237       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11238       case PURE_T:{
11239         if (!hasError) {
11240         t = jj_consume_token(PURE_T);
11241         }
11242         break;
11243         }
11244       case IMPURE_T:{
11245         if (!hasError) {
11246         t = jj_consume_token(IMPURE_T);
11247         }
11248         break;
11249         }
11250       default:
11251         jj_la1[296] = jj_gen;
11252         jj_consume_token(-1);
11253         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11254       }
11255       break;
11256       }
11257     default:
11258       jj_la1[297] = jj_gen;
11259       ;
11260     }
11261     }
11262     if (!hasError) {
11263     jj_consume_token(FUNCTION_T);
11264     }
11265     if (!hasError) {
11266     s = name();
11267     }
11268     if (!hasError) {
11269     s1 = param();
11270     }
11271     if (!hasError) {
11272     jj_consume_token(RETURN_T);
11273     }
11274     if (!hasError) {
11275     s2 = name();
11276     }
11277     if (!hasError) {
11278     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11279     case IS_T:{
11280       if (!hasError) {
11281       t1 = jj_consume_token(IS_T);
11282       }
11283       if (!hasError) {
11284       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11285       case BASIC_IDENTIFIER:
11286       case EXTENDED_CHARACTER:{
11287         if (!hasError) {
11288         s3 = identifier();
11289         }
11290         break;
11291         }
11292       case BOX_T:{
11293         if (!hasError) {
11294         t2 = jj_consume_token(BOX_T);
11295         }
11296         break;
11297         }
11298       default:
11299         jj_la1[298] = jj_gen;
11300         jj_consume_token(-1);
11301         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11302       }
11303       }
11304       break;
11305       }
11306     default:
11307       jj_la1[299] = jj_gen;
11308       ;
11309     }
11310     }
11311 QCString q;
11312    if(t) q=t->image.data();
11313    if(t2) s3="<>";
11314    if (!s3.isEmpty())
11315    {
11316      s3.prepend(" is ");
11317    }
11318    m_sharedState->current->name=s;
11319    if (m_sharedState->parse_sec==GEN_SEC)
11320    {
11321      QCString ss=q+" function "+s1+" return "+s2+s3;
11322      int a=outlineParser()->getLine(FUNCTION_T);
11323      int b=outlineParser()->getLine(PROCEDURE_T);
11324 
11325      if (a>b) b=a;
11326      outlineParser()->addVhdlType(m_sharedState->current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
11327    }
11328    m_sharedState->currP=0;return QCString();
11329 assert(false);
11330 }
11331 
11332 
param()11333 QCString VhdlParser::param() {QCString s,s1;Token *tok=0;
11334     if (!hasError) {
11335     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11336     case PARAMETER_T:{
11337       if (!hasError) {
11338       tok = jj_consume_token(PARAMETER_T);
11339       }
11340       break;
11341       }
11342     default:
11343       jj_la1[300] = jj_gen;
11344       ;
11345     }
11346     }
11347     if (!hasError) {
11348 m_sharedState->param_sec=PARAM_SEC;
11349     }
11350     if (!hasError) {
11351     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11352     case LPAREN_T:{
11353       if (!hasError) {
11354       jj_consume_token(LPAREN_T);
11355       }
11356       if (!hasError) {
11357       s1 = interface_list();
11358       }
11359       if (!hasError) {
11360       jj_consume_token(RPAREN_T);
11361       }
11362       break;
11363       }
11364     default:
11365       jj_la1[301] = jj_gen;
11366       ;
11367     }
11368     }
11369 if(tok)
11370     {
11371       s = tok->image.data();
11372     }
11373     m_sharedState->param_sec=0;
11374     return s+"("+s1+")";
11375 assert(false);
11376 }
11377 
11378 
parseInline()11379 void VhdlParser::parseInline() {
11380     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
11381     case POSTPONED_T:
11382     case PROCESS_T:
11383     case BASIC_IDENTIFIER:
11384     case EXTENDED_CHARACTER:{
11385       if (!hasError) {
11386       process_statement();
11387       }
11388       break;
11389       }
11390     case FUNCTION_T:
11391     case IMPURE_T:
11392     case PROCEDURE_T:
11393     case PURE_T:{
11394       if (!hasError) {
11395       subprogram_declaration();
11396       }
11397       break;
11398       }
11399     default:
11400       jj_la1[302] = jj_gen;
11401       jj_consume_token(-1);
11402       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
11403     }
11404 }
11405 
11406 
VhdlParser(TokenManager * tokenManager)11407   VhdlParser::VhdlParser(TokenManager *tokenManager){
11408     head = nullptr;
11409     ReInit(tokenManager);
11410 }
~VhdlParser()11411 VhdlParser::~VhdlParser()
11412 {
11413   clear();
11414 }
11415 
ReInit(TokenManager * tokenManager)11416 void VhdlParser::ReInit(TokenManager* tokenManager){
11417     clear();
11418     errorHandler = new ErrorHandler();
11419     hasError = false;
11420     token_source = tokenManager;
11421     head = token = new Token();
11422     token->kind = 0;
11423     token->next = nullptr;
11424     jj_lookingAhead = false;
11425     jj_rescan = false;
11426     jj_done = false;
11427     jj_scanpos = jj_lastpos = nullptr;
11428     jj_gc = 0;
11429     jj_kind = -1;
11430     indent = 0;
11431     trace = false;
11432     jj_ntk = -1;
11433     jj_gen = 0;
11434     for (int i = 0; i < 303; i++) jj_la1[i] = -1;
11435   }
11436 
11437 
clear()11438 void VhdlParser::clear(){
11439   //Since token manager was generate from outside,
11440   //parser should not take care of deleting
11441   //if (token_source) delete token_source;
11442   if (head) {
11443     Token *next, *t = head;
11444     while (t) {
11445       next = t->next;
11446       delete t;
11447       t = next;
11448     }
11449   }
11450   if (errorHandler) {
11451     delete errorHandler, errorHandler = nullptr;
11452   }
11453 }
11454 
11455 
jj_consume_token(int kind)11456 Token * VhdlParser::jj_consume_token(int kind)  {
11457     Token *oldToken;
11458     if ((oldToken = token)->next != nullptr) token = token->next;
11459     else token = token->next = token_source->getNextToken();
11460     jj_ntk = -1;
11461     if (token->kind == kind) {
11462       jj_gen++;
11463       if (++jj_gc > 100) {
11464         jj_gc = 0;
11465         for (int i = 0; i < 125; i++) {
11466           JJCalls *c = &jj_2_rtns[i];
11467           while (c != nullptr) {
11468             if (c->gen < jj_gen) c->first = nullptr;
11469             c = c->next;
11470           }
11471         }
11472       }
11473       return token;
11474     }
11475     token = oldToken;
11476     jj_kind = kind;
11477     JJString image = kind >= 0 ? tokenImage[kind] : tokenImage[0];
11478     errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this);
11479     hasError = true;
11480     return token;
11481   }
11482 
11483 
jj_scan_token(int kind)11484 bool  VhdlParser::jj_scan_token(int kind){
11485     if (jj_scanpos == jj_lastpos) {
11486       jj_la--;
11487       if (jj_scanpos->next == nullptr) {
11488         jj_lastpos = jj_scanpos = jj_scanpos->next = token_source->getNextToken();
11489       } else {
11490         jj_lastpos = jj_scanpos = jj_scanpos->next;
11491       }
11492     } else {
11493       jj_scanpos = jj_scanpos->next;
11494     }
11495     if (jj_rescan) {
11496       int i = 0; Token *tok = token;
11497       while (tok != nullptr && tok != jj_scanpos) { i++; tok = tok->next; }
11498       if (tok != nullptr) jj_add_error_token(kind, i);
11499     }
11500     if (jj_scanpos->kind != kind) return true;
11501     if (jj_la == 0 && jj_scanpos == jj_lastpos) { return jj_done = true; }
11502     return false;
11503   }
11504 
11505 
11506 /** Get the next Token. */
11507 
getNextToken()11508 Token * VhdlParser::getNextToken(){
11509     if (token->next != nullptr) token = token->next;
11510     else token = token->next = token_source->getNextToken();
11511     jj_ntk = -1;
11512     jj_gen++;
11513     return token;
11514   }
11515 
11516 /** Get the specific Token. */
11517 
getToken(int index)11518 Token * VhdlParser::getToken(int index){
11519     Token *t = token;
11520     for (int i = 0; i < index; i++) {
11521       if (t->next != nullptr) t = t->next;
11522       else t = t->next = token_source->getNextToken();
11523     }
11524     return t;
11525   }
11526 
11527 
jj_ntk_f()11528 int VhdlParser::jj_ntk_f(){
11529     if ((jj_nt=token->next) == nullptr)
11530       return (jj_ntk = (token->next=token_source->getNextToken())->kind);
11531     else
11532       return (jj_ntk = jj_nt->kind);
11533   }
11534 
11535 
jj_add_error_token(int kind,int pos)11536   void VhdlParser::jj_add_error_token(int kind, int pos)  {
11537   }
11538 
11539 
parseError()11540  void  VhdlParser::parseError()   {
11541       fprintf(stderr, "Parse error at: %d:%d, after token: %s encountered: %s\n", token->beginLine, token->beginColumn, addUnicodeEscapes(token->image).c_str(), addUnicodeEscapes(getToken(1)->image).c_str());
11542    }
11543 
11544 
trace_enabled()11545   bool VhdlParser::trace_enabled()  {
11546     return trace;
11547   }
11548 
11549 
enable_tracing()11550   void VhdlParser::enable_tracing()  {
11551   }
11552 
disable_tracing()11553   void VhdlParser::disable_tracing()  {
11554   }
11555 
11556 
jj_rescan_token()11557   void VhdlParser::jj_rescan_token(){
11558     jj_rescan = true;
11559     for (int i = 0; i < 125; i++) {
11560       JJCalls *p = &jj_2_rtns[i];
11561       do {
11562         if (p->gen > jj_gen) {
11563           jj_la = p->arg; jj_lastpos = jj_scanpos = p->first;
11564           switch (i) {
11565             case 0: jj_3_1(); break;
11566             case 1: jj_3_2(); break;
11567             case 2: jj_3_3(); break;
11568             case 3: jj_3_4(); break;
11569             case 4: jj_3_5(); break;
11570             case 5: jj_3_6(); break;
11571             case 6: jj_3_7(); break;
11572             case 7: jj_3_8(); break;
11573             case 8: jj_3_9(); break;
11574             case 9: jj_3_10(); break;
11575             case 10: jj_3_11(); break;
11576             case 11: jj_3_12(); break;
11577             case 12: jj_3_13(); break;
11578             case 13: jj_3_14(); break;
11579             case 14: jj_3_15(); break;
11580             case 15: jj_3_16(); break;
11581             case 16: jj_3_17(); break;
11582             case 17: jj_3_18(); break;
11583             case 18: jj_3_19(); break;
11584             case 19: jj_3_20(); break;
11585             case 20: jj_3_21(); break;
11586             case 21: jj_3_22(); break;
11587             case 22: jj_3_23(); break;
11588             case 23: jj_3_24(); break;
11589             case 24: jj_3_25(); break;
11590             case 25: jj_3_26(); break;
11591             case 26: jj_3_27(); break;
11592             case 27: jj_3_28(); break;
11593             case 28: jj_3_29(); break;
11594             case 29: jj_3_30(); break;
11595             case 30: jj_3_31(); break;
11596             case 31: jj_3_32(); break;
11597             case 32: jj_3_33(); break;
11598             case 33: jj_3_34(); break;
11599             case 34: jj_3_35(); break;
11600             case 35: jj_3_36(); break;
11601             case 36: jj_3_37(); break;
11602             case 37: jj_3_38(); break;
11603             case 38: jj_3_39(); break;
11604             case 39: jj_3_40(); break;
11605             case 40: jj_3_41(); break;
11606             case 41: jj_3_42(); break;
11607             case 42: jj_3_43(); break;
11608             case 43: jj_3_44(); break;
11609             case 44: jj_3_45(); break;
11610             case 45: jj_3_46(); break;
11611             case 46: jj_3_47(); break;
11612             case 47: jj_3_48(); break;
11613             case 48: jj_3_49(); break;
11614             case 49: jj_3_50(); break;
11615             case 50: jj_3_51(); break;
11616             case 51: jj_3_52(); break;
11617             case 52: jj_3_53(); break;
11618             case 53: jj_3_54(); break;
11619             case 54: jj_3_55(); break;
11620             case 55: jj_3_56(); break;
11621             case 56: jj_3_57(); break;
11622             case 57: jj_3_58(); break;
11623             case 58: jj_3_59(); break;
11624             case 59: jj_3_60(); break;
11625             case 60: jj_3_61(); break;
11626             case 61: jj_3_62(); break;
11627             case 62: jj_3_63(); break;
11628             case 63: jj_3_64(); break;
11629             case 64: jj_3_65(); break;
11630             case 65: jj_3_66(); break;
11631             case 66: jj_3_67(); break;
11632             case 67: jj_3_68(); break;
11633             case 68: jj_3_69(); break;
11634             case 69: jj_3_70(); break;
11635             case 70: jj_3_71(); break;
11636             case 71: jj_3_72(); break;
11637             case 72: jj_3_73(); break;
11638             case 73: jj_3_74(); break;
11639             case 74: jj_3_75(); break;
11640             case 75: jj_3_76(); break;
11641             case 76: jj_3_77(); break;
11642             case 77: jj_3_78(); break;
11643             case 78: jj_3_79(); break;
11644             case 79: jj_3_80(); break;
11645             case 80: jj_3_81(); break;
11646             case 81: jj_3_82(); break;
11647             case 82: jj_3_83(); break;
11648             case 83: jj_3_84(); break;
11649             case 84: jj_3_85(); break;
11650             case 85: jj_3_86(); break;
11651             case 86: jj_3_87(); break;
11652             case 87: jj_3_88(); break;
11653             case 88: jj_3_89(); break;
11654             case 89: jj_3_90(); break;
11655             case 90: jj_3_91(); break;
11656             case 91: jj_3_92(); break;
11657             case 92: jj_3_93(); break;
11658             case 93: jj_3_94(); break;
11659             case 94: jj_3_95(); break;
11660             case 95: jj_3_96(); break;
11661             case 96: jj_3_97(); break;
11662             case 97: jj_3_98(); break;
11663             case 98: jj_3_99(); break;
11664             case 99: jj_3_100(); break;
11665             case 100: jj_3_101(); break;
11666             case 101: jj_3_102(); break;
11667             case 102: jj_3_103(); break;
11668             case 103: jj_3_104(); break;
11669             case 104: jj_3_105(); break;
11670             case 105: jj_3_106(); break;
11671             case 106: jj_3_107(); break;
11672             case 107: jj_3_108(); break;
11673             case 108: jj_3_109(); break;
11674             case 109: jj_3_110(); break;
11675             case 110: jj_3_111(); break;
11676             case 111: jj_3_112(); break;
11677             case 112: jj_3_113(); break;
11678             case 113: jj_3_114(); break;
11679             case 114: jj_3_115(); break;
11680             case 115: jj_3_116(); break;
11681             case 116: jj_3_117(); break;
11682             case 117: jj_3_118(); break;
11683             case 118: jj_3_119(); break;
11684             case 119: jj_3_120(); break;
11685             case 120: jj_3_121(); break;
11686             case 121: jj_3_122(); break;
11687             case 122: jj_3_123(); break;
11688             case 123: jj_3_124(); break;
11689             case 124: jj_3_125(); break;
11690           }
11691         }
11692         p = p->next;
11693       } while (p != nullptr);
11694     }
11695     jj_rescan = false;
11696   }
11697 
11698 
jj_save(int index,int xla)11699   void VhdlParser::jj_save(int index, int xla){
11700     JJCalls *p = &jj_2_rtns[index];
11701     while (p->gen > jj_gen) {
11702       if (p->next == nullptr) { p = p->next = new JJCalls(); break; }
11703       p = p->next;
11704     }
11705     p->gen = jj_gen + xla - jj_la; p->first = token; p->arg = xla;
11706   }
11707 
11708 
11709 }
11710 }
11711