vhdlparser/VhdlParser.cc

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