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