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