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