Revert to use of javacc-6.1.3 due to regression

1 files changed, 3747 insertions, 1914 deletions

diff --git a/vhdlparser/VhdlParser.cc b/vhdlparser/VhdlParser.cc
index 35f2ff6..1c36d01 100644
--- a/vhdlparser/VhdlParser.cc
+++ b/vhdlparser/VhdlParser.cc
@@ -1,6 +1,5 @@
 /* VhdlParser.cc */
-#include "VhdlParser.h"
-#include "TokenMgrError.h"
+#include "/Users/dimitri/doxygen/vhdlparser/VhdlParser.h"
 namespace vhdl {
 namespace parser {
   unsigned int jj_la1_0[] = {
@@ -23,31 +22,37 @@ namespace parser {
 
 QCString VhdlParser::abstract_literal() {Token *tok;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case DECIMAL_LITERAL:{
-      if (!hasError) {
+    case DECIMAL_LITERAL:{if (!hasError) {
+      
       tok = jj_consume_token(DECIMAL_LITERAL);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case INTEGER:{
-      if (!hasError) {
+    case INTEGER:{if (!hasError) {
+      
       tok = jj_consume_token(INTEGER);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case BASED_LITERAL:{
-      if (!hasError) {
+    case BASED_LITERAL:{if (!hasError) {
+      
       tok = jj_consume_token(BASED_LITERAL);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -56,104 +61,122 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::access_type_definition() {Token *tok=0;QCString str,str1;
-    if (!hasError) {
+QCString VhdlParser::access_type_definition() {Token *tok=0;QCString str,str1;if (!hasError) {
+    
     tok = jj_consume_token(ACCESS_T);
     }
     if (!hasError) {
+    
     str1 = subtype_indication();
     }
+    
 str=tok->image.c_str(); return str+str1;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::actual_designator() {QCString str;Token *t=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case OPEN_T:{
-      if (!hasError) {
+    case OPEN_T:{if (!hasError) {
+      
       t = jj_consume_token(OPEN_T);
       }
       if (!hasError) {
+      
 return t->image.c_str();
       }
+      
       break;
       }
     default:
       jj_la1[1] = jj_gen;
-      if (jj_2_1(2147483647)) {
-        if (!hasError) {
+      if (jj_2_1(2147483647)) {if (!hasError) {
+        
         str = expression();
         }
         if (!hasError) {
+        
 return str;
         }
-      } else if (jj_2_2(2147483647)) {
-        if (!hasError) {
+        
+      } else if (jj_2_2(2147483647)) {if (!hasError) {
+        
         str = name();
         }
         if (!hasError) {
+        
 return str;
         }
+        
       } else {
         jj_consume_token(-1);
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::actual_parameter_part() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::actual_parameter_part() {QCString s;if (!hasError) {
+    
     s = association_list();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::actual_part() {QCString s,s1;
-    if (jj_2_3(2147483647)) {
-      if (!hasError) {
+    if (jj_2_3(2147483647)) {if (!hasError) {
+      
       s = actual_designator();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case BOX_T:{
-        if (!hasError) {
+      case BOX_T:{if (!hasError) {
+        
         jj_consume_token(BOX_T);
         }
         if (!hasError) {
+        
 return "<>";
         }
+        
         break;
         }
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         s = name();
         }
         if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
         s1 = actual_designator();
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
         if (!hasError) {
+        
 s+="(";s+=s1+")";return s;
         }
+        
         break;
         }
       default:
@@ -163,36 +186,42 @@ s+="(";s+=s1+")";return s;
       }
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::adding_operator() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PLUS_T:{
-      if (!hasError) {
+    case PLUS_T:{if (!hasError) {
+      
       jj_consume_token(PLUS_T);
       }
       if (!hasError) {
+      
 return "+";
       }
+      
       break;
       }
-    case MINUS_T:{
-      if (!hasError) {
+    case MINUS_T:{if (!hasError) {
+      
       jj_consume_token(MINUS_T);
       }
       if (!hasError) {
+      
 return "-";
       }
+      
       break;
       }
-    case AMPERSAND_T:{
-      if (!hasError) {
+    case AMPERSAND_T:{if (!hasError) {
+      
       jj_consume_token(AMPERSAND_T);
       }
       if (!hasError) {
+      
 return "&";
       }
+      
       break;
       }
     default:
@@ -201,17 +230,19 @@ return "&";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::aggregate() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::aggregate() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s = element_association();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -221,49 +252,60 @@ QCString VhdlParser::aggregate() {QCString s,s1,s2;
       default:
         jj_la1[4] = jj_gen;
         goto end_label_1;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = element_association();
       }
       if (!hasError) {
+      
 s+=","+s1;
       }
+      
     }
     end_label_1: ;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return "("+s+")";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::alias_declaration() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::alias_declaration() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(ALIAS_T);
     }
     if (!hasError) {
+    
     s2 = alias_designator();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case COLON_T:{
-      if (!hasError) {
+    case COLON_T:{if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
       if (!hasError) {
+      
 s+=":";
       }
       if (!hasError) {
+      
       s1 = subtype_indication();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
       break;
       }
     default:
@@ -272,26 +314,33 @@ s+=s1;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 s+=" is ";
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
 s+=s1;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LBRACKET_T:{
-      if (!hasError) {
+    case LBRACKET_T:{if (!hasError) {
+      
       s1 = signature();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
       break;
       }
     default:
@@ -300,43 +349,51 @@ s+=s1;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 addVhdlType(s2.data(),getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
 
  return s2+" "+s+";";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::alias_designator() {Token *tok=0;QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CHARACTER_LITERAL:{
-      if (!hasError) {
+    case CHARACTER_LITERAL:{if (!hasError) {
+      
       tok = jj_consume_token(CHARACTER_LITERAL);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case STRINGLITERAL:{
-      if (!hasError) {
+    case STRINGLITERAL:{if (!hasError) {
+      
       s = operator_symbol();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -345,26 +402,30 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 void VhdlParser::allocator() {
-    if (jj_2_4(3)) {
-      if (!hasError) {
+    if (jj_2_4(3)) {if (!hasError) {
+      
       jj_consume_token(NEW_T);
       }
       if (!hasError) {
+      
       qualified_expression();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case NEW_T:{
-        if (!hasError) {
+      case NEW_T:{if (!hasError) {
+        
         jj_consume_token(NEW_T);
         }
         if (!hasError) {
+        
         subtype_indication();
         }
+        
         break;
         }
       default:
@@ -373,26 +434,31 @@ void VhdlParser::allocator() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::architecture_body() {QCString s,s1;
-    if (!hasError) {
+void VhdlParser::architecture_body() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(ARCHITECTURE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 QCString t=s1+"::"+s;
                   genLabels.resize(0);
                   pushLabel(genLabels,s1);
@@ -400,29 +466,36 @@ QCString t=s1+"::"+s;
                   addVhdlType(t,getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
     }
     if (!hasError) {
-    try {
-      if (!hasError) {
+    
+    try {if (!hasError) {
+      
       architecture_declarative_part();
       }
+      
     } catch ( ...) {
 error_skipto(BEGIN_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(BEGIN_T);
     }
     if (!hasError) {
+    
     architecture_statement_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ARCHITECTURE_T:{
-      if (!hasError) {
+    case ARCHITECTURE_T:{if (!hasError) {
+      
       jj_consume_token(ARCHITECTURE_T);
       }
+      
       break;
       }
     default:
@@ -431,14 +504,16 @@ error_skipto(BEGIN_T);
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -447,14 +522,16 @@ error_skipto(BEGIN_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+  }
 
 
-void VhdlParser::architecture_declarative_part() {
-    if (!hasError) {
+void VhdlParser::architecture_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -481,18 +558,20 @@ void VhdlParser::architecture_declarative_part() {
       default:
         jj_la1[11] = jj_gen;
         goto end_label_2;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       block_declarative_item();
       }
+      
     }
     end_label_2: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::architecture_statement_part() {
-    if (!hasError) {
+void VhdlParser::architecture_statement_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -512,33 +591,39 @@ void VhdlParser::architecture_statement_part() {
       default:
         jj_la1[12] = jj_gen;
         goto end_label_3;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       concurrent_statement();
       }
+      
     }
     end_label_3: ;
     }
-}
+    
+  }
 
 
 QCString VhdlParser::array_type_definition() {QCString s;
-    if (jj_2_5(2147483647)) {
-      if (!hasError) {
+    if (jj_2_5(2147483647)) {if (!hasError) {
+      
       s = unconstraint_array_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case ARRAY_T:{
-        if (!hasError) {
+      case ARRAY_T:{if (!hasError) {
+        
         s = constraint_array_definition();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
@@ -548,25 +633,29 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;
-    if (!hasError) {
+QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
+    
     jj_consume_token(ASSERT_T);
     }
     if (!hasError) {
+    
     s = condition();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case REPORT_T:{
-      if (!hasError) {
+    case REPORT_T:{if (!hasError) {
+      
       t = jj_consume_token(REPORT_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
+      
       break;
       }
     default:
@@ -575,14 +664,17 @@ QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case SEVERITY_T:{
-      if (!hasError) {
+    case SEVERITY_T:{if (!hasError) {
+      
       t1 = jj_consume_token(SEVERITY_T);
       }
       if (!hasError) {
+      
       s2 = expression();
       }
+      
       break;
       }
     default:
@@ -590,25 +682,28 @@ QCString VhdlParser::assertion() {QCString s,s1,s2;Token *t=0;Token *t1=0;
       ;
     }
     }
+    
 s.prepend("assert ");
    if(t) s1.prepend(" report ");
    if(t1) s2.prepend(" report ");
     return s+s1+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::assertion_statement() {QCString s,s1,s2;Token *t=0;
-    if (!hasError) {
+QCString VhdlParser::assertion_statement() {QCString s,s1,s2;Token *t=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = label();
       }
       if (!hasError) {
+      
       t = jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -617,43 +712,51 @@ QCString VhdlParser::assertion_statement() {QCString s,s1,s2;Token *t=0;
     }
     }
     if (!hasError) {
+    
     s1 = assertion();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(t) s+=":";
     return s+s1+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::association_element() {QCString s,s1;
-    if (!hasError) {
-    if (jj_2_6(2147483647)) {
-      if (!hasError) {
+QCString VhdlParser::association_element() {QCString s,s1;if (!hasError) {
+    
+    if (jj_2_6(2147483647)) {if (!hasError) {
+      
       s = formal_part();
       }
       if (!hasError) {
+      
       jj_consume_token(ARROW_T);
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     s1 = actual_part();
     }
+    
 return s+" => "+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::association_list() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::association_list() {QCString s,s1;if (!hasError) {
+    
     s = association_element();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -663,65 +766,78 @@ QCString VhdlParser::association_list() {QCString s,s1;
       default:
         jj_la1[17] = jj_gen;
         goto end_label_4;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = association_element();
       }
       if (!hasError) {
+      
 s+=","+s1;
       }
+      
     }
     end_label_4: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::attribute_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::attribute_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(ATTRIBUTE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = type_mark();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
     return " attribute "+s+":"+s1+";";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::attribute_designator() {QCString s;Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case RANGE_T:{
-      if (!hasError) {
+    case RANGE_T:{if (!hasError) {
+      
       tok = jj_consume_token(RANGE_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -730,37 +846,45 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::attribute_name() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::attribute_name() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(APOSTROPHE_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
 s+="'"+s1;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s+"("+s1+")";
       }
+      
       break;
       }
     default:
@@ -768,104 +892,120 @@ s+"("+s1+")";
       ;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::attribute_specification() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::attribute_specification() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(ATTRIBUTE_T);
     }
     if (!hasError) {
+    
     s = attribute_designator();
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s1 = entity_specification();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     s2 = expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCString t= s1+" is "+s2;
    addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
    return " attribute "+s+" of "+s1+ " is "+s2+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::base() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::base() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(INTEGER);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::base_specifier() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::base_specifier() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BASIC_IDENTIFIER);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::base_unit_declaration() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::base_unit_declaration() {QCString s;if (!hasError) {
+    
     s = identifier();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::based_integer() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::based_integer() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BASIC_IDENTIFIER);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::based_literal() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::based_literal() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BASED_LITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::basic_identifier() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::basic_identifier() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BASIC_IDENTIFIER);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-void VhdlParser::binding_indication() {
-    if (!hasError) {
+void VhdlParser::binding_indication() {if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       jj_consume_token(USE_T);
       }
       if (!hasError) {
+      
       entity_aspect();
       }
+      
       break;
       }
     default:
@@ -874,11 +1014,13 @@ void VhdlParser::binding_indication() {
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       generic_map_aspect();
       }
+      
       break;
       }
     default:
@@ -887,11 +1029,13 @@ void VhdlParser::binding_indication() {
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PORT_T:{
-      if (!hasError) {
+    case PORT_T:{if (!hasError) {
+      
       port_map_aspect();
       }
+      
       break;
       }
     default:
@@ -899,35 +1043,40 @@ void VhdlParser::binding_indication() {
       ;
     }
     }
-}
+    
+  }
 
 
-QCString VhdlParser::bit_string_literal() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::bit_string_literal() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BIT_STRING_LITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::bit_value() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::bit_value() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(BASIC_IDENTIFIER);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-void VhdlParser::block_configuration() {
-    if (!hasError) {
+void VhdlParser::block_configuration() {if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     block_specification();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case USE_T:{
@@ -937,14 +1086,16 @@ void VhdlParser::block_configuration() {
       default:
         jj_la1[23] = jj_gen;
         goto end_label_5;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       use_clause();
       }
+      
     }
     end_label_5: ;
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case FOR_T:{
@@ -954,23 +1105,28 @@ void VhdlParser::block_configuration() {
       default:
         jj_la1[24] = jj_gen;
         goto end_label_6;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       configuration_item();
       }
+      
     }
     end_label_6: ;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
 void VhdlParser::block_declarative_item() {
@@ -978,105 +1134,121 @@ void VhdlParser::block_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       type_declaration();
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       subtype_declaration();
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       constant_declaration();
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       signal_declaration();
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       variable_declaration();
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       file_declaration();
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       alias_declaration();
       }
+      
       break;
       }
-    case COMPONENT_T:{
-      if (!hasError) {
+    case COMPONENT_T:{if (!hasError) {
+      
       component_declaration();
       }
+      
       break;
       }
     default:
       jj_la1[25] = jj_gen;
-      if (jj_2_7(2147483647)) {
-        if (!hasError) {
+      if (jj_2_7(2147483647)) {if (!hasError) {
+        
         attribute_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           attribute_specification();
           }
+          
           break;
           }
-        case FOR_T:{
-          if (!hasError) {
+        case FOR_T:{if (!hasError) {
+          
           configuration_specification();
           }
+          
           break;
           }
-        case DISCONNECT_T:{
-          if (!hasError) {
+        case DISCONNECT_T:{if (!hasError) {
+          
           disconnection_specification();
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           use_clause();
           }
+          
           break;
           }
         default:
           jj_la1[26] = jj_gen;
-          if (jj_2_8(3)) {
-            if (!hasError) {
+          if (jj_2_8(3)) {if (!hasError) {
+            
             group_template_declaration();
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               group_declaration();
               }
+              
               break;
               }
             default:
@@ -1088,11 +1260,11 @@ void VhdlParser::block_declarative_item() {
         }
       }
     }
-}
+  }
 
 
-void VhdlParser::block_declarative_part() {
-    if (!hasError) {
+void VhdlParser::block_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -1119,31 +1291,36 @@ void VhdlParser::block_declarative_part() {
       default:
         jj_la1[28] = jj_gen;
         goto end_label_7;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       block_declarative_item();
       }
+      
     }
     end_label_7: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::block_header() {
-    if (!hasError) {
-    if (jj_2_9(2147483647)) {
-      if (!hasError) {
+void VhdlParser::block_header() {if (!hasError) {
+    
+    if (jj_2_9(2147483647)) {if (!hasError) {
+      
       generic_clause();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case GENERIC_T:{
-        if (!hasError) {
+      case GENERIC_T:{if (!hasError) {
+        
         generic_map_aspect();
         }
         if (!hasError) {
+        
         jj_consume_token(SEMI_T);
         }
+        
         break;
         }
       default:
@@ -1151,25 +1328,30 @@ void VhdlParser::block_header() {
         ;
       }
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PORT_T:{
-      if (!hasError) {
+    case PORT_T:{if (!hasError) {
+      
       port_clause();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case PORT_T:{
-        if (!hasError) {
+      case PORT_T:{if (!hasError) {
+        
         port_map_aspect();
         }
         if (!hasError) {
+        
         jj_consume_token(SEMI_T);
         }
+        
         break;
         }
       default:
@@ -1177,6 +1359,7 @@ void VhdlParser::block_header() {
         ;
       }
       }
+      
       break;
       }
     default:
@@ -1184,25 +1367,30 @@ void VhdlParser::block_header() {
       ;
     }
     }
-}
+    
+  }
 
 
-void VhdlParser::block_specification() {
-    if (!hasError) {
+void VhdlParser::block_specification() {if (!hasError) {
+    
     name();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       index_specification();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
+      
       break;
       }
     default:
@@ -1210,34 +1398,42 @@ void VhdlParser::block_specification() {
       ;
     }
     }
-}
+    
+  }
 
 
-void VhdlParser::block_statement() {QCString s;
-    if (!hasError) {
+void VhdlParser::block_statement() {QCString s;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BLOCK_T);
     }
     if (!hasError) {
+    
 pushLabel(genLabels,s);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       expression();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
+      
       break;
       }
     default:
@@ -1246,11 +1442,13 @@ pushLabel(genLabels,s);
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       jj_consume_token(IS_T);
       }
+      
       break;
       }
     default:
@@ -1259,30 +1457,38 @@ pushLabel(genLabels,s);
     }
     }
     if (!hasError) {
+    
     block_header();
     }
     if (!hasError) {
+    
     block_declarative_part();
     }
     if (!hasError) {
+    
     jj_consume_token(BEGIN_T);
     }
     if (!hasError) {
+    
     block_statement_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BLOCK_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -1291,14 +1497,16 @@ pushLabel(genLabels,s);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 genLabels=popLabel(genLabels);
-}
+  }
 
 
-void VhdlParser::block_statement_part() {
-    if (!hasError) {
+void VhdlParser::block_statement_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -1318,27 +1526,31 @@ void VhdlParser::block_statement_part() {
       default:
         jj_la1[36] = jj_gen;
         goto end_label_8;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       concurrent_statement();
       }
+      
     }
     end_label_8: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::case_statement() {QCString s;
-    if (!hasError) {
+void VhdlParser::case_statement() {QCString s;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -1347,22 +1559,28 @@ void VhdlParser::case_statement() {QCString s;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(CASE_T);
     }
     if (!hasError) {
+    
     s = expression();
     }
     if (!hasError) {
+    
 QCString ca="case "+s;
      FlowChart::addFlowChart(FlowChart::CASE_NO,0,ca);
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     case_statement_alternative();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case WHEN_T:{
@@ -1372,26 +1590,31 @@ QCString ca="case "+s;
       default:
         jj_la1[38] = jj_gen;
         goto end_label_9;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       case_statement_alternative();
       }
+      
     }
     end_label_9: ;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(CASE_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -1400,75 +1623,91 @@ QCString ca="case "+s;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 FlowChart::moveToPrevLevel();
          FlowChart::addFlowChart(FlowChart::END_CASE,"end case",0);
-}
+  }
 
 
-void VhdlParser::case_statement_alternative() {QCString s;
-    if (!hasError) {
+void VhdlParser::case_statement_alternative() {QCString s;if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     s = choices();
     }
     if (!hasError) {
+    
     jj_consume_token(ARROW_T);
     }
     if (!hasError) {
+    
 QCString t="when ";
     t+=s+"=> ";
     FlowChart::addFlowChart(FlowChart::WHEN_NO,s.data(),t);
     }
     if (!hasError) {
+    
     sequence_of_statement();
     }
+    
 FlowChart::moveToPrevLevel();
-}
+  }
 
 
-QCString VhdlParser::character_literal() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::character_literal() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(CHARACTER_LITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::choice() {QCString s;
-    if (jj_2_10(2147483647)) {
-      if (!hasError) {
+    if (jj_2_10(2147483647)) {if (!hasError) {
+      
       s = discrete_range();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_11(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_11(2147483647)) {if (!hasError) {
+      
       s = simple_expression();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_12(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_12(2147483647)) {if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case OTHER_T:{
-        if (!hasError) {
+      case OTHER_T:{if (!hasError) {
+        
         jj_consume_token(OTHER_T);
         }
         if (!hasError) {
+        
 return " others ";
         }
+        
         break;
         }
       default:
@@ -1478,14 +1717,15 @@ return " others ";
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::choices() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::choices() {QCString s,s1;if (!hasError) {
+    
     s = choice();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case BAR_T:{
@@ -1495,43 +1735,51 @@ QCString VhdlParser::choices() {QCString s,s1;
       default:
         jj_la1[41] = jj_gen;
         goto end_label_10;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(BAR_T);
       }
       if (!hasError) {
+      
       s1 = choice();
       }
       if (!hasError) {
+      
 s+="|";s+=s1;
       }
+      
     }
     end_label_10: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::component_configuration() {
-    if (!hasError) {
+void VhdlParser::component_configuration() {if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     component_specification();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case GENERIC_T:
     case PORT_T:
     case USE_T:
-    case SEMI_T:{
-      if (!hasError) {
+    case SEMI_T:{if (!hasError) {
+      
       binding_indication();
       }
       if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
+      
       break;
       }
     default:
@@ -1540,11 +1788,13 @@ void VhdlParser::component_configuration() {
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case FOR_T:{
-      if (!hasError) {
+    case FOR_T:{if (!hasError) {
+      
       block_configuration();
       }
+      
       break;
       }
     default:
@@ -1553,30 +1803,37 @@ void VhdlParser::component_configuration() {
     }
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::component_declaration() {QCString s;
-    if (!hasError) {
+void VhdlParser::component_declaration() {QCString s;if (!hasError) {
+    
     jj_consume_token(COMPONENT_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       jj_consume_token(IS_T);
       }
+      
       break;
       }
     default:
@@ -1585,14 +1842,17 @@ void VhdlParser::component_declaration() {QCString s;
     }
     }
     if (!hasError) {
+    
 currP=VhdlDocGen::COMPONENT;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       generic_clause();
       }
+      
       break;
       }
     default:
@@ -1601,11 +1861,13 @@ currP=VhdlDocGen::COMPONENT;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PORT_T:{
-      if (!hasError) {
+    case PORT_T:{if (!hasError) {
+      
       port_clause();
       }
+      
       break;
       }
     default:
@@ -1614,22 +1876,27 @@ currP=VhdlDocGen::COMPONENT;
     }
     }
     if (!hasError) {
+    
 addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
      currP=0;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(COMPONENT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -1638,22 +1905,27 @@ addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPON
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::component_instantiation_statement() {QCString s,s1;
-    if (!hasError) {
+void VhdlParser::component_instantiation_statement() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = instantiation_unit();
     }
     if (!hasError) {
+    
 QCString s3;
        if (s1.contains("|")) {
          s3=VhdlDocGen::getIndexWord(s1.data(),0);
@@ -1663,20 +1935,24 @@ QCString s3;
        addCompInst(s.lower().data(),s1.lower().data(),s3.data(),getLine());
     }
     if (!hasError) {
-    if (jj_2_13(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_13(2147483647)) {if (!hasError) {
+      
       generic_map_aspect();
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PORT_T:{
-      if (!hasError) {
+    case PORT_T:{if (!hasError) {
+      
       port_map_aspect();
       }
+      
       break;
       }
     default:
@@ -1685,42 +1961,51 @@ QCString s3;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::component_specification() {
-    if (!hasError) {
+void VhdlParser::component_specification() {if (!hasError) {
+    
     instantiation_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     name();
     }
-}
+    
+  }
 
 
 QCString VhdlParser::composite_type_definition() {QCString s,s1;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ARRAY_T:{
-      if (!hasError) {
+    case ARRAY_T:{if (!hasError) {
+      
       s = array_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case RECORD_T:{
-      if (!hasError) {
+    case RECORD_T:{if (!hasError) {
+      
       record_type_definition();
       }
       if (!hasError) {
+      
 return s+"#";
       }
+      
       break;
       }
     default:
@@ -1729,28 +2014,32 @@ return s+"#";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-void VhdlParser::concurrent_assertion_statement() {
-    if (!hasError) {
-    if (jj_2_14(2)) {
-      if (!hasError) {
+void VhdlParser::concurrent_assertion_statement() {if (!hasError) {
+    
+    if (jj_2_14(2)) {if (!hasError) {
+      
       identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case POSTPONED_T:{
-      if (!hasError) {
+    case POSTPONED_T:{if (!hasError) {
+      
       jj_consume_token(POSTPONED_T);
       }
+      
       break;
       }
     default:
@@ -1759,33 +2048,40 @@ void VhdlParser::concurrent_assertion_statement() {
     }
     }
     if (!hasError) {
+    
     assertion();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::concurrent_procedure_call_statement() {
-    if (!hasError) {
-    if (jj_2_15(2)) {
-      if (!hasError) {
+void VhdlParser::concurrent_procedure_call_statement() {if (!hasError) {
+    
+    if (jj_2_15(2)) {if (!hasError) {
+      
       identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case POSTPONED_T:{
-      if (!hasError) {
+    case POSTPONED_T:{if (!hasError) {
+      
       jj_consume_token(POSTPONED_T);
       }
+      
       break;
       }
     default:
@@ -1794,33 +2090,40 @@ void VhdlParser::concurrent_procedure_call_statement() {
     }
     }
     if (!hasError) {
+    
     procedure_call();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::concurrent_signal_assignment_statement() {
-    if (!hasError) {
-    if (jj_2_16(2)) {
-      if (!hasError) {
+void VhdlParser::concurrent_signal_assignment_statement() {if (!hasError) {
+    
+    if (jj_2_16(2)) {if (!hasError) {
+      
       identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case POSTPONED_T:{
-      if (!hasError) {
+    case POSTPONED_T:{if (!hasError) {
+      
       jj_consume_token(POSTPONED_T);
       }
+      
       break;
       }
     default:
@@ -1829,16 +2132,19 @@ void VhdlParser::concurrent_signal_assignment_statement() {
     }
     }
     if (!hasError) {
-    if (jj_2_17(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_17(2147483647)) {if (!hasError) {
+      
       conditional_signal_assignment();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case WITH_T:{
-        if (!hasError) {
+      case WITH_T:{if (!hasError) {
+        
         selected_signal_assignment();
         }
+        
         break;
         }
       default:
@@ -1848,54 +2154,64 @@ void VhdlParser::concurrent_signal_assignment_statement() {
       }
     }
     }
-}
+    
+  }
 
 
 void VhdlParser::concurrent_statement() {
-    if (jj_2_18(2147483647)) {
-      if (!hasError) {
+    if (jj_2_18(2147483647)) {if (!hasError) {
+      
       block_statement();
       }
-    } else if (jj_2_19(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_19(2147483647)) {if (!hasError) {
+      
       process_statement();
       }
-    } else if (jj_2_20(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_20(2147483647)) {if (!hasError) {
+      
       generate_statement();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case CASE_T:{
-        if (!hasError) {
+      case CASE_T:{if (!hasError) {
+        
         case_scheme();
         }
+        
         break;
         }
       default:
         jj_la1[54] = jj_gen;
-        if (jj_2_21(2147483647)) {
-          if (!hasError) {
+        if (jj_2_21(2147483647)) {if (!hasError) {
+          
           concurrent_assertion_statement();
           }
-        } else if (jj_2_22(2147483647)) {
-          if (!hasError) {
+          
+        } else if (jj_2_22(2147483647)) {if (!hasError) {
+          
           concurrent_signal_assignment_statement();
           }
-        } else if (jj_2_23(2147483647)) {
-          if (!hasError) {
+          
+        } else if (jj_2_23(2147483647)) {if (!hasError) {
+          
           component_instantiation_statement();
           }
-        } else if (jj_2_24(2147483647)) {
-          if (!hasError) {
+          
+        } else if (jj_2_24(2147483647)) {if (!hasError) {
+          
           concurrent_procedure_call_statement();
           }
+          
         } else {
           switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-          case VHDL2008TOOLDIR:{
-            if (!hasError) {
+          case VHDL2008TOOLDIR:{if (!hasError) {
+            
             jj_consume_token(VHDL2008TOOLDIR);
             }
+            
             break;
             }
           default:
@@ -1906,84 +2222,100 @@ void VhdlParser::concurrent_statement() {
         }
       }
     }
-}
+  }
 
 
-QCString VhdlParser::condition() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::condition() {QCString s;if (!hasError) {
+    
     s = expression();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::condition_clause() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::condition_clause() {QCString s;if (!hasError) {
+    
     jj_consume_token(UNTIL_T);
     }
     if (!hasError) {
+    
     s = condition();
     }
+    
 return " until "+s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::conditional_signal_assignment() {
-    if (!hasError) {
+void VhdlParser::conditional_signal_assignment() {if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     options();
     }
     if (!hasError) {
+    
     conditional_waveforms();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::conditional_waveforms() {
-    if (!hasError) {
+void VhdlParser::conditional_waveforms() {if (!hasError) {
+    
     waveform();
     }
     if (!hasError) {
+    
     while (!hasError) {
       if (jj_2_25(2147483647)) {
         ;
       } else {
         goto end_label_11;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       condition();
       }
       if (!hasError) {
+      
       jj_consume_token(ELSE_T);
       }
       if (!hasError) {
+      
       waveform();
       }
+      
     }
     end_label_11: ;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case WHEN_T:{
-      if (!hasError) {
+    case WHEN_T:{if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       condition();
       }
+      
       break;
       }
     default:
@@ -1991,44 +2323,55 @@ void VhdlParser::conditional_waveforms() {
       ;
     }
     }
-}
+    
+  }
 
 
-void VhdlParser::configuration_declaration() {QCString s,s1;
-    if (!hasError) {
+void VhdlParser::configuration_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(CONFIGURATION_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 confName=s+"::"+s1;
   addVhdlType(s.data(),getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
     }
     if (!hasError) {
+    
     configuration_declarative_part();
     }
     if (!hasError) {
+    
     block_configuration();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case CONFIGURATION_T:{
-      if (!hasError) {
+    case CONFIGURATION_T:{if (!hasError) {
+      
       jj_consume_token(CONFIGURATION_T);
       }
+      
       break;
       }
     default:
@@ -2037,14 +2380,16 @@ confName=s+"::"+s1;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -2053,30 +2398,35 @@ confName=s+"::"+s1;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 genLabels.resize(0); confName="";
-}
+  }
 
 
 void VhdlParser::configuration_declarative_item() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       use_clause();
       }
+      
       break;
       }
-    case ATTRIBUTE_T:{
-      if (!hasError) {
+    case ATTRIBUTE_T:{if (!hasError) {
+      
       attribute_specification();
       }
+      
       break;
       }
-    case GROUP_T:{
-      if (!hasError) {
+    case GROUP_T:{if (!hasError) {
+      
       group_declaration();
       }
+      
       break;
       }
     default:
@@ -2084,11 +2434,11 @@ void VhdlParser::configuration_declarative_item() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::configuration_declarative_part() {
-    if (!hasError) {
+void VhdlParser::configuration_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ATTRIBUTE_T:
@@ -2100,27 +2450,31 @@ void VhdlParser::configuration_declarative_part() {
       default:
         jj_la1[60] = jj_gen;
         goto end_label_12;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       configuration_declarative_item();
       }
+      
     }
     end_label_12: ;
     }
-}
+    
+  }
 
 
 void VhdlParser::configuration_item() {
-    if (jj_2_26(2147483647)) {
-      if (!hasError) {
+    if (jj_2_26(2147483647)) {if (!hasError) {
+      
       component_configuration();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case FOR_T:{
-        if (!hasError) {
+      case FOR_T:{if (!hasError) {
+        
         block_configuration();
         }
+        
         break;
         }
       default:
@@ -2129,47 +2483,57 @@ void VhdlParser::configuration_item() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::configuration_specification() {
-    if (!hasError) {
+void VhdlParser::configuration_specification() {if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     component_specification();
     }
     if (!hasError) {
+    
     binding_indication();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;
-    if (!hasError) {
+QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;if (!hasError) {
+    
     jj_consume_token(CONSTANT_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case VARASSIGN_T:{
-      if (!hasError) {
+    case VARASSIGN_T:{if (!hasError) {
+      
       t = jj_consume_token(VARASSIGN_T);
       }
       if (!hasError) {
+      
       s2 = expression();
       }
+      
       break;
       }
     default:
@@ -2178,8 +2542,10 @@ QCString VhdlParser::constant_declaration() {QCString s,s1,s2;Token *t=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(t)
       s2.prepend(":=");
      QCString it=s1+s2;
@@ -2187,29 +2553,33 @@ if(t)
      it.prepend("constant ");
      return it;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::constraint_array_definition() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::constraint_array_definition() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(ARRAY_T);
     }
     if (!hasError) {
+    
     s = index_constraint();
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
+    
 return s+" "+s1;
 assert(false);
-}
+  }
 
 
-void VhdlParser::context_clause() {
-    if (!hasError) {
+void VhdlParser::context_clause() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case LIBRARY_T:
@@ -2220,51 +2590,59 @@ void VhdlParser::context_clause() {
       default:
         jj_la1[63] = jj_gen;
         goto end_label_13;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       context_item();
       }
+      
     }
     end_label_13: ;
     }
-}
+    
+  }
 
 
 QCString VhdlParser::constraint() {QCString s;
-    if (jj_2_27(2147483647)) {
-      if (!hasError) {
+    if (jj_2_27(2147483647)) {if (!hasError) {
+      
       s = range_constraint();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_28(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_28(2147483647)) {if (!hasError) {
+      
       s = index_constraint();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 void VhdlParser::context_item() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LIBRARY_T:{
-      if (!hasError) {
+    case LIBRARY_T:{if (!hasError) {
+      
       library_clause();
       }
+      
       break;
       }
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       use_clause();
       }
+      
       break;
       }
     default:
@@ -2272,43 +2650,49 @@ void VhdlParser::context_item() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-QCString VhdlParser::decimal_literal() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::decimal_literal() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(DECIMAL_LITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::delay_mechanism() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case TRANSPORT_T:{
-      if (!hasError) {
+    case TRANSPORT_T:{if (!hasError) {
+      
       jj_consume_token(TRANSPORT_T);
       }
       if (!hasError) {
+      
 return " transport ";
       }
+      
       break;
       }
     case INERTIAL_T:
-    case REJECT_T:{
-      if (!hasError) {
+    case REJECT_T:{if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case REJECT_T:{
-        if (!hasError) {
+      case REJECT_T:{if (!hasError) {
+        
         jj_consume_token(REJECT_T);
         }
         if (!hasError) {
+        
         s = expression();
         }
         if (!hasError) {
+        
 s.prepend(" reject ");
         }
+        
         break;
         }
       default:
@@ -2317,11 +2701,14 @@ s.prepend(" reject ");
       }
       }
       if (!hasError) {
+      
       jj_consume_token(INERTIAL_T);
       }
       if (!hasError) {
+      
 return s+" inertial ";
       }
+      
       break;
       }
     default:
@@ -2330,7 +2717,7 @@ return s+" inertial ";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 void VhdlParser::design_file() {
@@ -2341,12 +2728,13 @@ void VhdlParser::design_file() {
     case ENTITY_T:
     case LIBRARY_T:
     case PACKAGE_T:
-    case USE_T:{
-      if (!hasError) {
-      while (!hasError) {
-        if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
+      while (!hasError) {if (!hasError) {
+        
         design_unit();
         }
+        
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case ARCHITECTURE_T:
         case CONFIGURATION_T:
@@ -2366,14 +2754,17 @@ void VhdlParser::design_file() {
       end_label_14: ;
       }
       if (!hasError) {
+      
 
       }
+      
       break;
       }
-    case 0:{
-      if (!hasError) {
+    case 0:{if (!hasError) {
+      
       jj_consume_token(0);
       }
+      
       break;
       }
     default:
@@ -2381,38 +2772,44 @@ void VhdlParser::design_file() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::design_unit() {
-    if (!hasError) {
+void VhdlParser::design_unit() {if (!hasError) {
+    
     context_clause();
     }
     if (!hasError) {
+    
     library_unit();
     }
-}
+    
+  }
 
 
 QCString VhdlParser::designator() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case STRINGLITERAL:{
-      if (!hasError) {
+    case STRINGLITERAL:{if (!hasError) {
+      
       s = operator_symbol();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -2421,27 +2818,31 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::direction() {Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case TO_T:{
-      if (!hasError) {
+    case TO_T:{if (!hasError) {
+      
       tok = jj_consume_token(TO_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case DOWNTO_T:{
-      if (!hasError) {
+    case DOWNTO_T:{if (!hasError) {
+      
       tok = jj_consume_token(DOWNTO_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -2450,131 +2851,157 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-void VhdlParser::disconnection_specification() {
-    if (!hasError) {
+void VhdlParser::disconnection_specification() {if (!hasError) {
+    
     jj_consume_token(DISCONNECT_T);
     }
     if (!hasError) {
+    
     guarded_signal_specificatio();
     }
     if (!hasError) {
+    
     jj_consume_token(AFTER_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::guarded_signal_specificatio() {
-    if (!hasError) {
+void VhdlParser::guarded_signal_specificatio() {if (!hasError) {
+    
     signal_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     name();
     }
-}
+    
+  }
 
 
 QCString VhdlParser::discrete_range() {QCString s;
-    if (jj_2_29(2147483647)) {
-      if (!hasError) {
+    if (jj_2_29(2147483647)) {if (!hasError) {
+      
       s = range();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_30(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_30(2147483647)) {if (!hasError) {
+      
       s = subtype_indication();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::element_association() {QCString s,s1;
-    if (!hasError) {
-    if (jj_2_31(2147483647)) {
-      if (!hasError) {
+QCString VhdlParser::element_association() {QCString s,s1;if (!hasError) {
+    
+    if (jj_2_31(2147483647)) {if (!hasError) {
+      
       s = choices();
       }
       if (!hasError) {
+      
       jj_consume_token(ARROW_T);
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     s1 = expression();
     }
+    
 if(!s.isEmpty())
  return s+"=>"+s1;
 return s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::element_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::element_declaration() {QCString s,s1;if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
   //addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
   return s+":"+s1;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::entity_aspect() {Token *tok=0;QCString s,s1;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ENTITY_T:{
-      if (!hasError) {
+    case ENTITY_T:{if (!hasError) {
+      
       tok = jj_consume_token(ENTITY_T);
       }
       if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
         s1 = identifier();
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
         if (!hasError) {
+        
 s+="("+s1+")";
         }
+        
         break;
         }
       default:
@@ -2583,29 +3010,36 @@ s+="("+s1+")";
       }
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CONFIGURATION_T:{
-      if (!hasError) {
+    case CONFIGURATION_T:{if (!hasError) {
+      
       tok = jj_consume_token(CONFIGURATION_T);
       }
       if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return tok->image.c_str()+s;
       }
+      
       break;
       }
-    case OPEN_T:{
-      if (!hasError) {
+    case OPEN_T:{if (!hasError) {
+      
       tok = jj_consume_token(OPEN_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -2614,162 +3048,196 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::entity_class() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ENTITY_T:{
-      if (!hasError) {
+    case ENTITY_T:{if (!hasError) {
+      
       jj_consume_token(ENTITY_T);
       }
       if (!hasError) {
+      
 return "entity";
       }
+      
       break;
       }
-    case ARCHITECTURE_T:{
-      if (!hasError) {
+    case ARCHITECTURE_T:{if (!hasError) {
+      
       jj_consume_token(ARCHITECTURE_T);
       }
       if (!hasError) {
+      
 return "architecture";
       }
+      
       break;
       }
-    case CONFIGURATION_T:{
-      if (!hasError) {
+    case CONFIGURATION_T:{if (!hasError) {
+      
       jj_consume_token(CONFIGURATION_T);
       }
       if (!hasError) {
+      
 return "configuration";
       }
+      
       break;
       }
-    case PROCEDURE_T:{
-      if (!hasError) {
+    case PROCEDURE_T:{if (!hasError) {
+      
       jj_consume_token(PROCEDURE_T);
       }
       if (!hasError) {
+      
 return "procedure";
       }
+      
       break;
       }
-    case FUNCTION_T:{
-      if (!hasError) {
+    case FUNCTION_T:{if (!hasError) {
+      
       jj_consume_token(FUNCTION_T);
       }
       if (!hasError) {
+      
 return "function";
       }
+      
       break;
       }
-    case PACKAGE_T:{
-      if (!hasError) {
+    case PACKAGE_T:{if (!hasError) {
+      
       jj_consume_token(PACKAGE_T);
       }
       if (!hasError) {
+      
 return "package";
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       jj_consume_token(TYPE_T);
       }
       if (!hasError) {
+      
 return "type";
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       jj_consume_token(SUBTYPE_T);
       }
       if (!hasError) {
+      
 return "subtype";
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       jj_consume_token(CONSTANT_T);
       }
       if (!hasError) {
+      
 return "constant";
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       jj_consume_token(SIGNAL_T);
       }
       if (!hasError) {
+      
 return "signal";
       }
+      
       break;
       }
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       jj_consume_token(VARIABLE_T);
       }
       if (!hasError) {
+      
 return "variable";
       }
+      
       break;
       }
-    case COMPONENT_T:{
-      if (!hasError) {
+    case COMPONENT_T:{if (!hasError) {
+      
       jj_consume_token(COMPONENT_T);
       }
       if (!hasError) {
+      
 return "component";
       }
+      
       break;
       }
-    case LABEL_T:{
-      if (!hasError) {
+    case LABEL_T:{if (!hasError) {
+      
       jj_consume_token(LABEL_T);
       }
       if (!hasError) {
+      
 return "label";
       }
+      
       break;
       }
-    case LITERAL_T:{
-      if (!hasError) {
+    case LITERAL_T:{if (!hasError) {
+      
       jj_consume_token(LITERAL_T);
       }
       if (!hasError) {
+      
 return "literal";
       }
+      
       break;
       }
-    case UNITS_T:{
-      if (!hasError) {
+    case UNITS_T:{if (!hasError) {
+      
       jj_consume_token(UNITS_T);
       }
       if (!hasError) {
+      
 return "units";
       }
+      
       break;
       }
-    case GROUP_T:{
-      if (!hasError) {
+    case GROUP_T:{if (!hasError) {
+      
       jj_consume_token(GROUP_T);
       }
       if (!hasError) {
+      
 return "group";
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       jj_consume_token(FILE_T);
       }
       if (!hasError) {
+      
 return "file";
       }
+      
       break;
       }
     default:
@@ -2778,22 +3246,25 @@ return "file";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::entity_class_entry() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::entity_class_entry() {QCString s;if (!hasError) {
+    
     s = entity_class();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case BOX_T:{
-      if (!hasError) {
+    case BOX_T:{if (!hasError) {
+      
       jj_consume_token(BOX_T);
       }
       if (!hasError) {
+      
 s+="<>";
       }
+      
       break;
       }
     default:
@@ -2801,21 +3272,25 @@ s+="<>";
       ;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::entity_class_entry_list() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::entity_class_entry_list() {QCString s,s1,s2;if (!hasError) {
     if (!hasError) {
+    
     s1 = entity_class_entry();
     }
     if (!hasError) {
+    
 s+=s1;
     }
+    
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -2825,54 +3300,66 @@ s+=s1;
       default:
         jj_la1[75] = jj_gen;
         goto end_label_15;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s = entity_class_entry();
       }
       if (!hasError) {
+      
 s2+=",";s2+=s;
       }
+      
     }
     end_label_15: ;
     }
+    
 return s1+s2;
 assert(false);
-}
+  }
 
 
-void VhdlParser::entity_declaration() {QCString s;
-    if (!hasError) {
+void VhdlParser::entity_declaration() {QCString s;if (!hasError) {
+    
     jj_consume_token(ENTITY_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 lastEntity=current.get();
                 lastCompound=0;
                 addVhdlType(s.data(),getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
     }
     if (!hasError) {
+    
     entity_header();
     }
     if (!hasError) {
+    
     entity_declarative_part();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case BEGIN_T:{
-      if (!hasError) {
+    case BEGIN_T:{if (!hasError) {
+      
       jj_consume_token(BEGIN_T);
       }
       if (!hasError) {
+      
       entity_statement_part();
       }
+      
       break;
       }
     default:
@@ -2881,14 +3368,17 @@ lastEntity=current.get();
     }
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ENTITY_T:{
-      if (!hasError) {
+    case ENTITY_T:{if (!hasError) {
+      
       jj_consume_token(ENTITY_T);
       }
+      
       break;
       }
     default:
@@ -2897,14 +3387,16 @@ lastEntity=current.get();
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -2913,10 +3405,12 @@ lastEntity=current.get();
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+  }
 
 
 void VhdlParser::entity_declarative_item() {
@@ -2924,113 +3418,130 @@ void VhdlParser::entity_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       type_declaration();
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       subtype_declaration();
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       constant_declaration();
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       signal_declaration();
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       variable_declaration();
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       file_declaration();
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       alias_declaration();
       }
+      
       break;
       }
     default:
       jj_la1[79] = jj_gen;
-      if (jj_2_32(2147483647)) {
-        if (!hasError) {
+      if (jj_2_32(2147483647)) {if (!hasError) {
+        
         attribute_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           attribute_specification();
           }
+          
           break;
           }
-        case DISCONNECT_T:{
-          if (!hasError) {
+        case DISCONNECT_T:{if (!hasError) {
+          
           disconnection_specification();
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           use_clause();
           }
+          
           break;
           }
         default:
           jj_la1[80] = jj_gen;
-          if (jj_2_33(3)) {
-            if (!hasError) {
+          if (jj_2_33(3)) {if (!hasError) {
+            
             group_template_declaration();
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               group_declaration();
               }
+              
               break;
               }
             default:
               jj_la1[81] = jj_gen;
-              if (jj_2_34(5)) {
-                if (!hasError) {
+              if (jj_2_34(5)) {if (!hasError) {
+                
                 package_instantiation_declaration();
                 }
+                
               } else {
                 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-                case PACKAGE_T:{
-                  if (!hasError) {
+                case PACKAGE_T:{if (!hasError) {
+                  
                   package_declaration();
                   }
+                  
                   break;
                   }
-                case VHDL2008TOOLDIR:{
-                  if (!hasError) {
+                case VHDL2008TOOLDIR:{if (!hasError) {
+                  
                   jj_consume_token(VHDL2008TOOLDIR);
                   }
+                  
                   break;
                   }
                 default:
@@ -3044,11 +3555,11 @@ void VhdlParser::entity_declarative_item() {
         }
       }
     }
-}
+  }
 
 
-void VhdlParser::entity_declarative_part() {
-    if (!hasError) {
+void VhdlParser::entity_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -3075,26 +3586,30 @@ void VhdlParser::entity_declarative_part() {
       default:
         jj_la1[83] = jj_gen;
         goto end_label_16;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       entity_declarative_item();
       }
+      
     }
     end_label_16: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::entity_designator() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::entity_designator() {QCString s,s1;if (!hasError) {
+    
     s = entity_tag();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LBRACKET_T:{
-      if (!hasError) {
+    case LBRACKET_T:{if (!hasError) {
+      
       s1 = signature();
       }
+      
       break;
       }
     default:
@@ -3102,21 +3617,24 @@ QCString VhdlParser::entity_designator() {QCString s,s1;
       ;
     }
     }
+    
 return s+s1;
 assert(false);
-}
+  }
 
 
-void VhdlParser::entity_header() {
-    if (!hasError) {
+void VhdlParser::entity_header() {if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
 currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC;
       }
       if (!hasError) {
+      
       generic_clause();
       }
+      
       break;
       }
     default:
@@ -3125,14 +3643,17 @@ currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PORT_T:{
-      if (!hasError) {
+    case PORT_T:{if (!hasError) {
+      
 currP=VhdlDocGen::PORT;
       }
       if (!hasError) {
+      
       port_clause();
       }
+      
       break;
       }
     default:
@@ -3140,7 +3661,8 @@ currP=VhdlDocGen::PORT;
       ;
     }
     }
-}
+    
+  }
 
 
 QCString VhdlParser::entity_name_list() {QCString s,s1;
@@ -3149,15 +3671,17 @@ QCString VhdlParser::entity_name_list() {QCString s,s1;
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
     case EXTENDED_CHARACTER:
-    case CHARACTER_LITERAL:{
-      if (!hasError) {
-      while (!hasError) {
-        if (!hasError) {
+    case CHARACTER_LITERAL:{if (!hasError) {
+      
+      while (!hasError) {if (!hasError) {
+        
         s1 = entity_designator();
         }
         if (!hasError) {
+        
 s+=s1;
         }
+        
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case SLSL_T:
         case STRINGLITERAL:
@@ -3175,26 +3699,32 @@ s+=s1;
       end_label_17: ;
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case OTHER_T:{
-      if (!hasError) {
+    case OTHER_T:{if (!hasError) {
+      
       jj_consume_token(OTHER_T);
       }
       if (!hasError) {
+      
 return "other";
       }
+      
       break;
       }
-    case ALL_T:{
-      if (!hasError) {
+    case ALL_T:{if (!hasError) {
+      
       jj_consume_token(ALL_T);
       }
       if (!hasError) {
+      
 return "all";
       }
+      
       break;
       }
     default:
@@ -3203,43 +3733,49 @@ return "all";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::entity_specification() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::entity_specification() {QCString s,s1;if (!hasError) {
+    
     s = entity_name_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = entity_class();
     }
+    
 return s+":"+s1;
 assert(false);
-}
+  }
 
 
 void VhdlParser::entity_statement() {
-    if (jj_2_35(2147483647)) {
-      if (!hasError) {
+    if (jj_2_35(2147483647)) {if (!hasError) {
+      
       concurrent_assertion_statement();
       }
-    } else if (jj_2_36(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_36(2147483647)) {if (!hasError) {
+      
       process_statement();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case POSTPONED_T:
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         concurrent_procedure_call_statement();
         }
+        
         break;
         }
       default:
@@ -3248,11 +3784,11 @@ void VhdlParser::entity_statement() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::entity_statement_part() {
-    if (!hasError) {
+void VhdlParser::entity_statement_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -3268,14 +3804,16 @@ void VhdlParser::entity_statement_part() {
       default:
         jj_la1[90] = jj_gen;
         goto end_label_18;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       entity_statement();
       }
+      
     }
     end_label_18: ;
     }
-}
+    
+  }
 
 
 QCString VhdlParser::entity_tag() {QCString s;
@@ -3283,22 +3821,26 @@ QCString VhdlParser::entity_tag() {QCString s;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CHARACTER_LITERAL:{
-      if (!hasError) {
+    case CHARACTER_LITERAL:{if (!hasError) {
+      
       s = character_literal();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -3307,28 +3849,32 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::enumeration_literal() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CHARACTER_LITERAL:{
-      if (!hasError) {
+    case CHARACTER_LITERAL:{if (!hasError) {
+      
       s = character_literal();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -3337,17 +3883,19 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::enumeration_type_definition() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::enumeration_type_definition() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s = enumeration_literal();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -3357,38 +3905,45 @@ QCString VhdlParser::enumeration_type_definition() {QCString s,s1;
       default:
         jj_la1[93] = jj_gen;
         goto end_label_19;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = enumeration_literal();
       }
       if (!hasError) {
+      
 s+=",";s+=s1;
       }
+      
     }
     end_label_19: ;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return "("+s+")";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
-    if (!hasError) {
+QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       t = jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -3397,15 +3952,18 @@ QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(EXIT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s1 = identifier();
       }
+      
       break;
       }
     default:
@@ -3414,14 +3972,17 @@ QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case WHEN_T:{
-      if (!hasError) {
+    case WHEN_T:{if (!hasError) {
+      
       t1 = jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       s2 = condition();
       }
+      
       break;
       }
     default:
@@ -3430,8 +3991,10 @@ QCString VhdlParser::exit_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 lab.resize(0);
   if(t) s+=":";
   if(t1) s2.prepend(" when ");
@@ -3439,14 +4002,15 @@ lab.resize(0);
 
   return s+s1+s2+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::expression() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::expression() {QCString s,s1,s2;if (!hasError) {
+    
     s = relation();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case AND_T:
@@ -3461,78 +4025,94 @@ QCString VhdlParser::expression() {QCString s,s1,s2;
       default:
         jj_la1[97] = jj_gen;
         goto end_label_20;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = logop();
       }
       if (!hasError) {
+      
       s2 = relation();
       }
       if (!hasError) {
+      
 s+=s1;s+=s2;
       }
+      
     }
     end_label_20: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::logop() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case AND_T:{
-      if (!hasError) {
+    case AND_T:{if (!hasError) {
+      
       jj_consume_token(AND_T);
       }
       if (!hasError) {
+      
 return "and" ;
       }
+      
       break;
       }
-    case NAND_T:{
-      if (!hasError) {
+    case NAND_T:{if (!hasError) {
+      
       jj_consume_token(NAND_T);
       }
       if (!hasError) {
+      
 return "nand" ;
       }
+      
       break;
       }
-    case NOR_T:{
-      if (!hasError) {
+    case NOR_T:{if (!hasError) {
+      
       jj_consume_token(NOR_T);
       }
       if (!hasError) {
+      
 return "nor" ;
       }
+      
       break;
       }
-    case XNOR_T:{
-      if (!hasError) {
+    case XNOR_T:{if (!hasError) {
+      
       jj_consume_token(XNOR_T);
       }
       if (!hasError) {
+      
 return "xnor" ;
       }
+      
       break;
       }
-    case XOR_T:{
-      if (!hasError) {
+    case XOR_T:{if (!hasError) {
+      
       jj_consume_token(XOR_T);
       }
       if (!hasError) {
+      
 return "xor" ;
       }
+      
       break;
       }
-    case OR_T:{
-      if (!hasError) {
+    case OR_T:{if (!hasError) {
+      
       jj_consume_token(OR_T);
       }
       if (!hasError) {
+      
 return "or" ;
       }
+      
       break;
       }
     default:
@@ -3541,16 +4121,17 @@ return "or" ;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::extended_identifier() {Token *t;
-    if (!hasError) {
+QCString VhdlParser::extended_identifier() {Token *t;if (!hasError) {
+    
     t = jj_consume_token(EXTENDED_CHARACTER);
     }
+    
 return t->image.c_str();
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::factor() {QCString s,s1;
@@ -3566,22 +4147,26 @@ QCString VhdlParser::factor() {QCString s,s1;
     case CHARACTER_LITERAL:
     case DECIMAL_LITERAL:
     case BASED_LITERAL:
-    case BIT_STRING_LITERAL:{
-      if (!hasError) {
+    case BIT_STRING_LITERAL:{if (!hasError) {
+      
       s = primary();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case DOUBLEMULT_T:{
-        if (!hasError) {
+      case DOUBLEMULT_T:{if (!hasError) {
+        
         jj_consume_token(DOUBLEMULT_T);
         }
         if (!hasError) {
+        
         s1 = primary();
         }
         if (!hasError) {
+        
 s+="**";s+=s1;
         }
+        
         break;
         }
       default:
@@ -3590,32 +4175,40 @@ s+="**";s+=s1;
       }
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case ABS_T:{
-      if (!hasError) {
+    case ABS_T:{if (!hasError) {
+      
       jj_consume_token(ABS_T);
       }
       if (!hasError) {
+      
       s = primary();
       }
       if (!hasError) {
+      
 s1 = "abs "; return s1+s;
       }
+      
       break;
       }
-    case NOT_T:{
-      if (!hasError) {
+    case NOT_T:{if (!hasError) {
+      
       jj_consume_token(NOT_T);
       }
       if (!hasError) {
+      
       s = primary();
       }
       if (!hasError) {
+      
 s1="not ";return s1+s;
       }
+      
       break;
       }
     default:
@@ -3624,29 +4217,34 @@ s1="not ";return s1+s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;
-    if (!hasError) {
+QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;if (!hasError) {
+    
     jj_consume_token(FILE_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s2 = subtype_indication();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case IS_T:
-    case OPEN_T:{
-      if (!hasError) {
+    case OPEN_T:{if (!hasError) {
+      
       s3 = file_open_information();
       }
+      
       break;
       }
     default:
@@ -3655,34 +4253,39 @@ QCString VhdlParser::file_declaration() {QCString s,s1,s2,s3;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCString t1=s2+" "+s3;
    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
    return " file "+s+":"+s2+" "+s3+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::file_logical_name() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::file_logical_name() {QCString s;if (!hasError) {
+    
     s = expression();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::file_open_information() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::file_open_information() {QCString s,s1,s2;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case OPEN_T:{
-      if (!hasError) {
+    case OPEN_T:{if (!hasError) {
+      
       jj_consume_token(OPEN_T);
       }
       if (!hasError) {
+      
       s = expression();
       }
+      
       break;
       }
     default:
@@ -3691,38 +4294,45 @@ QCString VhdlParser::file_open_information() {QCString s,s1,s2;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     s1 = file_logical_name();
     }
+    
 s2="open "+s+" is "+s1;  return s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::file_type_definition() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::file_type_definition() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(FILE_T);
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s = type_mark();
     }
+    
 s1=" file of "+s; return s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::floating_type_definition() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::floating_type_definition() {QCString s;if (!hasError) {
+    
     s = range_constraint();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::formal_designator() {QCString s;Token *tok=0;
@@ -3730,22 +4340,26 @@ QCString VhdlParser::formal_designator() {QCString s;Token *tok=0;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case INTEGER:{
-      if (!hasError) {
+    case INTEGER:{if (!hasError) {
+      
       tok = jj_consume_token(INTEGER);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -3754,37 +4368,43 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::formal_parameter_list() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::formal_parameter_list() {QCString s;if (!hasError) {
+    
     s = interface_list();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::formal_part() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::formal_part() {QCString s,s1;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       formal_designator();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s+"("+s1+")";
       }
+      
       break;
       }
     default:
@@ -3792,37 +4412,45 @@ s+"("+s1+")";
       ;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::full_type_declaration() {Entry *tmpEntry;QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::full_type_declaration() {Entry *tmpEntry;QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(TYPE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 tmpEntry=current.get();
   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
     }
     if (!hasError) {
-    try {
-      if (!hasError) {
+    
+    try {if (!hasError) {
+      
       s2 = type_definition();
       }
+      
     } catch ( ...) {
 error_skipto(SEMI_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if (s2.contains("#")) {
         VhdlDocGen::deleteAllChars(s2,'#');
         tmpEntry->spec=VhdlDocGen::RECORD;
@@ -3843,65 +4471,79 @@ if (s2.contains("#")) {
       tmpEntry=0;
       return "type "+s+" is "+s2+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::function_call() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::function_call() {QCString s,s1;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s1 = actual_parameter_part();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return s+"("+s1+")";
 assert(false);
-}
+  }
 
 
-void VhdlParser::generate_statement() {QCString s;
-    if (!hasError) {
+void VhdlParser::generate_statement() {QCString s;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
-    try {
-      if (!hasError) {
+    
+    try {if (!hasError) {
+      
       generate_scheme();
       }
       if (!hasError) {
+      
       jj_consume_token(GENERATE_T);
       }
       if (!hasError) {
+      
 pushLabel(genLabels,s);
       }
       if (!hasError) {
+      
       generate_statement_body1();
       }
       if (!hasError) {
+      
       jj_consume_token(END_T);
       }
+      
     } catch ( ...) {
 error_skipto(GENERATE_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(GENERATE_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -3910,30 +4552,36 @@ error_skipto(GENERATE_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 genLabels=popLabel(genLabels);
-}
+  }
 
 
 void VhdlParser::generate_scheme() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case FOR_T:{
-      if (!hasError) {
+    case FOR_T:{if (!hasError) {
+      
       jj_consume_token(FOR_T);
       }
       if (!hasError) {
+      
       parameter_specification();
       }
+      
       break;
       }
-    case IF_T:{
-      if (!hasError) {
+    case IF_T:{if (!hasError) {
+      
       jj_consume_token(IF_T);
       }
       if (!hasError) {
+      
       condition();
       }
+      
       break;
       }
     default:
@@ -3941,58 +4589,70 @@ void VhdlParser::generate_scheme() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::generic_clause() {QCString s;
-    if (!hasError) {
+void VhdlParser::generic_clause() {QCString s;if (!hasError) {
+    
     jj_consume_token(GENERIC_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
 parse_sec=GEN_SEC;
     }
     if (!hasError) {
+    
     s = generic_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 parse_sec=0;
-}
+  }
 
 
-QCString VhdlParser::generic_list() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::generic_list() {QCString s;if (!hasError) {
+    
     s = interface_list();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::generic_map_aspect() {
-    if (!hasError) {
+void VhdlParser::generic_map_aspect() {if (!hasError) {
+    
     jj_consume_token(GENERIC_T);
     }
     if (!hasError) {
+    
     jj_consume_token(MAP_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     association_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
-}
+    
+  }
 
 
 QCString VhdlParser::group_constituent() {QCString s;
@@ -4000,22 +4660,26 @@ QCString VhdlParser::group_constituent() {QCString s;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CHARACTER_LITERAL:{
-      if (!hasError) {
+    case CHARACTER_LITERAL:{if (!hasError) {
+      
       s = character_literal();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -4024,16 +4688,18 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::group_constituent_list() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::group_constituent_list() {QCString s,s1,s2;if (!hasError) {
     if (!hasError) {
+    
     s1 = group_constituent();
     }
+    
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -4043,112 +4709,138 @@ QCString VhdlParser::group_constituent_list() {QCString s,s1,s2;
       default:
         jj_la1[108] = jj_gen;
         goto end_label_21;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s = group_constituent();
       }
       if (!hasError) {
+      
 s2+=",";s2+=s1;
       }
+      
     }
     end_label_21: ;
     }
+    
 return s+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::group_declaration() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::group_declaration() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(GROUP_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s2 = group_constituent_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return "group "+s+":"+s1+"("+s2+");";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::group_template_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::group_template_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(GROUP_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s1 = entity_class_entry_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return "group "+s+ "is ("+s1+");";
 assert(false);
-}
+  }
 
 
-void VhdlParser::guarded_signal_specification() {
-    if (!hasError) {
+void VhdlParser::guarded_signal_specification() {if (!hasError) {
+    
     signal_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     type_mark();
     }
-}
+    
+  }
 
 
 QCString VhdlParser::identifier() {Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       tok = jj_consume_token(EXTENDED_CHARACTER);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case BASIC_IDENTIFIER:{
-      if (!hasError) {
+    case BASIC_IDENTIFIER:{if (!hasError) {
+      
       tok = jj_consume_token(BASIC_IDENTIFIER);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -4157,14 +4849,15 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::identifier_list() {QCString str,str1;
-    if (!hasError) {
+QCString VhdlParser::identifier_list() {QCString str,str1;if (!hasError) {
+    
     str = identifier();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -4174,35 +4867,41 @@ QCString VhdlParser::identifier_list() {QCString str,str1;
       default:
         jj_la1[110] = jj_gen;
         goto end_label_22;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       str1 = identifier();
       }
       if (!hasError) {
+      
 str+=",";str+=str1;
       }
+      
     }
     end_label_22: ;
     }
+    
 return str;
 assert(false);
-}
+  }
 
 
-void VhdlParser::if_statement() {QCString s,s1;
-    if (!hasError) {
+void VhdlParser::if_statement() {QCString s,s1;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -4211,22 +4910,28 @@ void VhdlParser::if_statement() {QCString s,s1;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(IF_T);
     }
     if (!hasError) {
+    
     s = condition();
     }
     if (!hasError) {
+    
     jj_consume_token(THEN_T);
     }
     if (!hasError) {
+    
 s.prepend("if ");
     FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
     }
     if (!hasError) {
+    
     sequence_of_statement();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ELSIF_T:{
@@ -4236,38 +4941,47 @@ s.prepend("if ");
       default:
         jj_la1[112] = jj_gen;
         goto end_label_23;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(ELSIF_T);
       }
       if (!hasError) {
+      
       s1 = condition();
       }
       if (!hasError) {
+      
       jj_consume_token(THEN_T);
       }
       if (!hasError) {
+      
 s1.prepend("elsif ");
            FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
       }
       if (!hasError) {
+      
       sequence_of_statement();
       }
+      
     }
     end_label_23: ;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ELSE_T:{
-      if (!hasError) {
+    case ELSE_T:{if (!hasError) {
+      
       jj_consume_token(ELSE_T);
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
       }
       if (!hasError) {
+      
       sequence_of_statement();
       }
+      
       break;
       }
     default:
@@ -4276,18 +4990,22 @@ FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(IF_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -4296,39 +5014,47 @@ FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 FlowChart::moveToPrevLevel();
           FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
-}
+  }
 
 
-QCString VhdlParser::incomplete_type_declaration() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::incomplete_type_declaration() {QCString s;if (!hasError) {
+    
     jj_consume_token(TYPE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return "type "+s+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::index_constraint() {QCString s="("; QCString s1,s2;
-    if (!hasError) {
+QCString VhdlParser::index_constraint() {QCString s="("; QCString s1,s2;if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s2 = discrete_range();
     }
     if (!hasError) {
+    
 s+=s2;
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -4338,35 +5064,42 @@ s+=s2;
       default:
         jj_la1[115] = jj_gen;
         goto end_label_24;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = discrete_range();
       }
       if (!hasError) {
+      
 s+=",";s+=s1;
       }
+      
     }
     end_label_24: ;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return s+")";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::index_specification() {QCString s;
-    if (jj_2_37(2147483647)) {
-      if (!hasError) {
+    if (jj_2_37(2147483647)) {if (!hasError) {
+      
       s = discrete_range();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ABS_T:
@@ -4384,13 +5117,15 @@ return s;
       case CHARACTER_LITERAL:
       case DECIMAL_LITERAL:
       case BASED_LITERAL:
-      case BIT_STRING_LITERAL:{
-        if (!hasError) {
+      case BIT_STRING_LITERAL:{if (!hasError) {
+        
         s = expression();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
@@ -4400,35 +5135,39 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::index_subtype_definition() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::index_subtype_definition() {QCString s;if (!hasError) {
+    
     s = type_mark();
     }
     if (!hasError) {
+    
     jj_consume_token(RANGE_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BOX_T);
     }
+    
 return s+" range <> ";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::instantiation_unit() {QCString s,s1,s2;Token *tok;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case COMPONENT_T:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case COMPONENT_T:{
-        if (!hasError) {
+      case COMPONENT_T:{if (!hasError) {
+        
         jj_consume_token(COMPONENT_T);
         }
+        
         break;
         }
       default:
@@ -4437,50 +5176,63 @@ QCString VhdlParser::instantiation_unit() {QCString s,s1,s2;Token *tok;
       }
       }
       if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
 s1="component "; return s;
       }
+      
       break;
       }
-    case ENTITY_T:{
-      if (!hasError) {
+    case ENTITY_T:{if (!hasError) {
+      
       jj_consume_token(ENTITY_T);
       }
       if (!hasError) {
-      if (jj_2_38(2)) {
-        if (!hasError) {
+      
+      if (jj_2_38(2)) {if (!hasError) {
+        
         jj_consume_token(BASIC_IDENTIFIER);
         }
         if (!hasError) {
+        
         jj_consume_token(DOT_T);
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
+      
       s2 = name();
       }
       if (!hasError) {
+      
 s="entity|"+s2;
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
         s1 = identifier();
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
         if (!hasError) {
+        
 s+="(";s+=s1;s+=")" ;
         }
+        
         break;
         }
       default:
@@ -4489,20 +5241,25 @@ s+="(";s+=s1;s+=")" ;
       }
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CONFIGURATION_T:{
-      if (!hasError) {
+    case CONFIGURATION_T:{if (!hasError) {
+      
       jj_consume_token(CONFIGURATION_T);
       }
       if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 s1="configuration ";return s;
       }
+      
       break;
       }
     default:
@@ -4511,37 +5268,43 @@ s1="configuration ";return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::instantiation_list() {QCString s;Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier_list();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case OTHER_T:{
-      if (!hasError) {
+    case OTHER_T:{if (!hasError) {
+      
       tok = jj_consume_token(OTHER_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case ALL_T:{
-      if (!hasError) {
+    case ALL_T:{if (!hasError) {
+      
       tok = jj_consume_token(ALL_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -4550,69 +5313,81 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::integer() {Token *t;
-    if (!hasError) {
+QCString VhdlParser::integer() {Token *t;if (!hasError) {
+    
     t = jj_consume_token(INTEGER);
     }
+    
 return t->image.c_str();
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::integer_type_definition() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::integer_type_definition() {QCString s;if (!hasError) {
+    
     s = range_constraint();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::interface_declaration() {QCString s,s1;
-    if (jj_2_39(5)) {
-      if (!hasError) {
+    if (jj_2_39(5)) {if (!hasError) {
+      
       s = interface_subprogram_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case PACKAGE_T:{
-        if (!hasError) {
+      case PACKAGE_T:{if (!hasError) {
+        
         interface_package_declaration();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
         jj_la1[121] = jj_gen;
-        if (jj_2_40(5)) {
-          if (!hasError) {
+        if (jj_2_40(5)) {if (!hasError) {
+          
           s = interface_variable_declaration();
           }
           if (!hasError) {
+          
 return s;
           }
-        } else if (jj_2_41(5)) {
-          if (!hasError) {
+          
+        } else if (jj_2_41(5)) {if (!hasError) {
+          
           interface_file_declaration();
           }
           if (!hasError) {
+          
 return s;
           }
-        } else if (jj_2_42(2147483647)) {
-          if (!hasError) {
+          
+        } else if (jj_2_42(2147483647)) {if (!hasError) {
+          
           subprogram_declaration();
           }
           if (!hasError) {
+          
 return s;
           }
+          
         } else {
           switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
           case CONSTANT_T:
@@ -4620,19 +5395,22 @@ return s;
           case SIGNAL_T:
           case SHARED_T:
           case TYPE_T:
-          case VARIABLE_T:{
-            if (!hasError) {
+          case VARIABLE_T:{if (!hasError) {
+            
             s = object_class();
             }
             if (!hasError) {
+            
             s1 = identifier();
             }
             if (!hasError) {
+            
 if (parse_sec==GEN_SEC)
 
     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,s1.data(),0,Public);
     return s;
             }
+            
             break;
             }
           default:
@@ -4644,42 +5422,48 @@ if (parse_sec==GEN_SEC)
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::interface_element() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::interface_element() {QCString s;if (!hasError) {
+    
     s = interface_declaration();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::interface_file_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::interface_file_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(FILE_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
+    
 addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
    return " file "+s+":"+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::interface_list() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::interface_list() {QCString s,s1,s2;if (!hasError) {
+    
     s = interface_element();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case SEMI_T:{
@@ -4689,55 +5473,63 @@ QCString VhdlParser::interface_list() {QCString s,s1,s2;
       default:
         jj_la1[123] = jj_gen;
         goto end_label_25;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
       if (!hasError) {
+      
       s1 = interface_element();
       }
       if (!hasError) {
+      
 s2+=";";s2+=s1;
       }
+      
     }
     end_label_25: ;
     }
+    
 return s+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;
-    if (!hasError) {
+QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case CONSTANT_T:
     case SIGNAL_T:
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case VARIABLE_T:{
-        if (!hasError) {
+      case VARIABLE_T:{if (!hasError) {
+        
         tok = jj_consume_token(VARIABLE_T);
         }
+        
         break;
         }
-      case SIGNAL_T:{
-        if (!hasError) {
+      case SIGNAL_T:{if (!hasError) {
+        
         tok = jj_consume_token(SIGNAL_T);
         }
+        
         break;
         }
-      case CONSTANT_T:{
-        if (!hasError) {
+      case CONSTANT_T:{if (!hasError) {
+        
         tok = jj_consume_token(CONSTANT_T);
         }
+        
         break;
         }
-      case SHARED_T:{
-        if (!hasError) {
+      case SHARED_T:{if (!hasError) {
+        
         tok = jj_consume_token(SHARED_T);
         }
+        
         break;
         }
       default:
@@ -4746,6 +5538,7 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
       }
+      
       break;
       }
     default:
@@ -4754,21 +5547,25 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
     }
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BUFFER_T:
     case IN_T:
     case INOUT_T:
     case LINKAGE_T:
-    case OUT_T:{
-      if (!hasError) {
+    case OUT_T:{if (!hasError) {
+      
       s1 = mode();
       }
+      
       break;
       }
     default:
@@ -4777,14 +5574,17 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
     }
     }
     if (!hasError) {
+    
     s2 = subtype_indication();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case BUS_T:{
-      if (!hasError) {
+    case BUS_T:{if (!hasError) {
+      
       tok1 = jj_consume_token(BUS_T);
       }
+      
       break;
       }
     default:
@@ -4793,14 +5593,17 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case VARASSIGN_T:{
-      if (!hasError) {
+    case VARASSIGN_T:{if (!hasError) {
+      
       tok2 = jj_consume_token(VARASSIGN_T);
       }
       if (!hasError) {
+      
       s4 = expression();
       }
+      
       break;
       }
     default:
@@ -4808,6 +5611,7 @@ QCString VhdlParser::interface_variable_declaration() {Token *tok=0;Token *tok1=
       ;
     }
     }
+    
 if(tok)
                     s5=tok->image.c_str();
 
@@ -4836,39 +5640,45 @@ if(tok)
                     } // if component
               return it;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::iteration_scheme() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case WHILE_T:{
-      if (!hasError) {
+    case WHILE_T:{if (!hasError) {
+      
       jj_consume_token(WHILE_T);
       }
       if (!hasError) {
+      
       s = condition();
       }
       if (!hasError) {
+      
 s.prepend("while ");
    FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),lab.data());
    lab="";
   return s;
       }
+      
       break;
       }
-    case FOR_T:{
-      if (!hasError) {
+    case FOR_T:{if (!hasError) {
+      
       jj_consume_token(FOR_T);
       }
       if (!hasError) {
+      
       s = parameter_specification();
       }
       if (!hasError) {
+      
 QCString q=lab+" for "+s;
     FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),lab.data());
     lab="";
     return q;
       }
+      
       break;
       }
     default:
@@ -4877,30 +5687,35 @@ QCString q=lab+" for "+s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::label() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::label() {QCString s;if (!hasError) {
+    
     s = identifier();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::library_clause() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::library_clause() {QCString s;if (!hasError) {
     if (!hasError) {
+    
     jj_consume_token(LIBRARY_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
     }
+    
 if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                    {
                            addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
@@ -4908,33 +5723,38 @@ if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
                    QCString s1="library "+s;
                    return s1;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::library_unit() {QCString s;
-    if (jj_2_43(2)) {
-      if (!hasError) {
+    if (jj_2_43(2)) {if (!hasError) {
+      
       primary_unit();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ARCHITECTURE_T:
-      case PACKAGE_T:{
-        if (!hasError) {
+      case PACKAGE_T:{if (!hasError) {
+        
         secondary_unit();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
-      case CONTEXT_T:{
-        if (!hasError) {
+      case CONTEXT_T:{if (!hasError) {
+        
         context_declaration();
         }
+        
         break;
         }
       default:
@@ -4944,49 +5764,59 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::literal() {QCString s;
-    if (jj_2_44(2147483647)) {
-      if (!hasError) {
+    if (jj_2_44(2147483647)) {if (!hasError) {
+      
       s = bit_string_literal();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_45(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_45(2147483647)) {if (!hasError) {
+      
       s = numeric_literal();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_46(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_46(2147483647)) {if (!hasError) {
+      
       s = enumeration_literal();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case STRINGLITERAL:{
-        if (!hasError) {
+      case STRINGLITERAL:{if (!hasError) {
+        
         s = string_literal();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
-      case NULL_T:{
-        if (!hasError) {
+      case NULL_T:{if (!hasError) {
+        
         jj_consume_token(NULL_T);
         }
         if (!hasError) {
+        
 return "null";
         }
+        
         break;
         }
       default:
@@ -4996,32 +5826,36 @@ return "null";
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::logical_operator() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::logical_operator() {QCString s;if (!hasError) {
+    
     s = logop();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::loop_statement() {QCString s,s1,s2,s3;
-    if (!hasError) {
+QCString VhdlParser::loop_statement() {QCString s,s1,s2,s3;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
       if (!hasError) {
+      
 s+=":";
       }
+      
       break;
       }
     default:
@@ -5030,12 +5864,14 @@ s+=":";
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case FOR_T:
-    case WHILE_T:{
-      if (!hasError) {
+    case WHILE_T:{if (!hasError) {
+      
       s1 = iteration_scheme();
       }
+      
       break;
       }
     default:
@@ -5044,28 +5880,35 @@ s+=":";
     }
     }
     if (!hasError) {
+    
 if(s1.isEmpty())
         FlowChart::addFlowChart(FlowChart::LOOP_NO,0,"infinite");
     }
     if (!hasError) {
+    
     jj_consume_token(LOOP_T);
     }
     if (!hasError) {
+    
     s2 = sequence_of_statement();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LOOP_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s3 = identifier();
       }
+      
       break;
       }
     default:
@@ -5074,44 +5917,52 @@ if(s1.isEmpty())
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCString q = s+" loop "+s2+" end loop" +s3;
          QCString endLoop="end loop" + s3;
          FlowChart::moveToPrevLevel();
          FlowChart::addFlowChart(FlowChart::END_LOOP,endLoop.data(),0);
         return q;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::miscellaneous_operator() {Token *t=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case DOUBLEMULT_T:{
-      if (!hasError) {
+    case DOUBLEMULT_T:{if (!hasError) {
+      
       jj_consume_token(DOUBLEMULT_T);
       }
       if (!hasError) {
+      
 return "**";
       }
+      
       break;
       }
-    case ABS_T:{
-      if (!hasError) {
+    case ABS_T:{if (!hasError) {
+      
       jj_consume_token(ABS_T);
       }
       if (!hasError) {
+      
 return "abs";
       }
+      
       break;
       }
-    case NOT_T:{
-      if (!hasError) {
+    case NOT_T:{if (!hasError) {
+      
       jj_consume_token(NOT_T);
       }
       if (!hasError) {
+      
 return "not";
       }
+      
       break;
       }
     default:
@@ -5120,54 +5971,64 @@ return "not";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::mode() {Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IN_T:{
-      if (!hasError) {
+    case IN_T:{if (!hasError) {
+      
       tok = jj_consume_token(IN_T);
       }
       if (!hasError) {
+      
 return "in";
       }
+      
       break;
       }
-    case OUT_T:{
-      if (!hasError) {
+    case OUT_T:{if (!hasError) {
+      
       tok = jj_consume_token(OUT_T);
       }
       if (!hasError) {
+      
 return "out";
       }
+      
       break;
       }
-    case INOUT_T:{
-      if (!hasError) {
+    case INOUT_T:{if (!hasError) {
+      
       tok = jj_consume_token(INOUT_T);
       }
       if (!hasError) {
+      
 return "inout";
       }
+      
       break;
       }
-    case BUFFER_T:{
-      if (!hasError) {
+    case BUFFER_T:{if (!hasError) {
+      
       tok = jj_consume_token(BUFFER_T);
       }
       if (!hasError) {
+      
 return "buffer";
       }
+      
       break;
       }
-    case LINKAGE_T:{
-      if (!hasError) {
+    case LINKAGE_T:{if (!hasError) {
+      
       tok = jj_consume_token(LINKAGE_T);
       }
       if (!hasError) {
+      
 return "linkage";
       }
+      
       break;
       }
     default:
@@ -5176,45 +6037,53 @@ return "linkage";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::multiplying_operation() {Token *tok=0;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case MULT_T:{
-      if (!hasError) {
+    case MULT_T:{if (!hasError) {
+      
       tok = jj_consume_token(MULT_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case SLASH_T:{
-      if (!hasError) {
+    case SLASH_T:{if (!hasError) {
+      
       tok = jj_consume_token(SLASH_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case MOD_T:{
-      if (!hasError) {
+    case MOD_T:{if (!hasError) {
+      
       tok = jj_consume_token(MOD_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
-    case REM_T:{
-      if (!hasError) {
+    case REM_T:{if (!hasError) {
+      
       tok = jj_consume_token(REM_T);
       }
       if (!hasError) {
+      
 return tok->image.c_str();
       }
+      
       break;
       }
     default:
@@ -5223,29 +6092,32 @@ return tok->image.c_str();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::name() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::name() {QCString s,s1;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case STRINGLITERAL:{
-      if (!hasError) {
+    case STRINGLITERAL:{if (!hasError) {
+      
       s = operator_symbol();
       }
+      
       break;
       }
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
+      
       break;
       }
-    case SLSL_T:{
-      if (!hasError) {
+    case SLSL_T:{if (!hasError) {
+      
       s = external_name();
       }
+      
       break;
       }
     default:
@@ -5255,90 +6127,123 @@ QCString VhdlParser::name() {QCString s,s1;
     }
     }
     if (!hasError) {
-    if (jj_2_47(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_47(2147483647)) {if (!hasError) {
+      
       s1 = name_ext1();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     } else {
       ;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::name_ext1() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::name_ext1() {QCString s,s1,s2;if (!hasError) {
+    
     s = name_ext();
     }
     if (!hasError) {
+    
     while (!hasError) {
       if (jj_2_48(2147483647)) {
         ;
       } else {
         goto end_label_26;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = name_ext();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     }
     end_label_26: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::name_ext() {QCString s,s1,s2;
-    if (!hasError) {
-    if (jj_2_49(2147483647)) {
+QCString VhdlParser::name_ext() {QCString s,s1,s2;if (!hasError) {
+    
+    if (jj_2_49(2147483647)) {if (!hasError) {
+      
+      jj_consume_token(APOSTROPHE_T);
+      }
       if (!hasError) {
+      
+      jj_consume_token(SUBTYPE_T);
+      }
+      if (!hasError) {
+      
+s+="'subtype";
+      }
+      
+    } else if (jj_2_50(2147483647)) {if (!hasError) {
+      
       jj_consume_token(DOT_T);
       }
       if (!hasError) {
+      
       s1 = suffix();
       }
       if (!hasError) {
+      
 s+=".";s+=s1;
       }
-    } else if (jj_2_50(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_51(2147483647)) {if (!hasError) {
+      
       s1 = test_att_name();
       }
       if (!hasError) {
+      
 s+=s1;
       }
-    } else if (jj_2_51(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_52(2147483647)) {if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = discrete_range();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s+="(";s+=s1;s+=")";
       }
-    } else if (jj_2_52(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_53(2147483647)) {if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
 s+="(";s+=s1;
       }
       if (!hasError) {
+      
       while (!hasError) {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case COMMA_T:{
@@ -5348,72 +6253,89 @@ s+="(";s+=s1;
         default:
           jj_la1[139] = jj_gen;
           goto end_label_27;
-        }
-        if (!hasError) {
+        }if (!hasError) {
+        
         jj_consume_token(COMMA_T);
         }
         if (!hasError) {
+        
         s1 = expression();
         }
         if (!hasError) {
+        
 s+=",";s+=s1;
         }
+        
       }
       end_label_27: ;
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s+=")";
       }
+      
     } else {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::test_att_name() {QCString s,s1;
-    if (!hasError) {
-    if (jj_2_53(2147483647)) {
-      if (!hasError) {
+QCString VhdlParser::test_att_name() {QCString s,s1;if (!hasError) {
+    
+    if (jj_2_54(2147483647)) {if (!hasError) {
+      
       s1 = signature();
       }
       if (!hasError) {
+      
 s=s1;
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(APOSTROPHE_T);
     }
     if (!hasError) {
+    
     s1 = attribute_designator();
     }
     if (!hasError) {
+    
 s+="'";s+=s1;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s+="(";s+=s1;s+=")";
       }
+      
       break;
       }
     default:
@@ -5421,25 +6343,30 @@ s+="(";s+=s1;s+=")";
       ;
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::indexed_name() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::indexed_name() {QCString s,s1,s2;if (!hasError) {
+    
     s2 = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s1 = expression();
     }
     if (!hasError) {
+    
 s=s2+"("+s1;
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -5449,38 +6376,45 @@ s=s2+"("+s1;
       default:
         jj_la1[141] = jj_gen;
         goto end_label_28;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
 s+=",";s+=s1;
       }
+      
     }
     end_label_28: ;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return s+")";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
-    if (!hasError) {
+QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       t = jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -5489,15 +6423,18 @@ QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(NEXT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s1 = identifier();
       }
+      
       break;
       }
     default:
@@ -5506,14 +6443,17 @@ QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case WHEN_T:{
-      if (!hasError) {
+    case WHEN_T:{if (!hasError) {
+      
       t1 = jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       s2 = condition();
       }
+      
       break;
       }
     default:
@@ -5522,31 +6462,36 @@ QCString VhdlParser::next_statement() {QCString s,s1,s2;Token *t=0;Token *t1=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(t) s+=":";
    FlowChart::addFlowChart(FlowChart::NEXT_NO,"next ",s2.data(),s1.data());
     lab.resize(0);
   if(t1) s2.prepend("when ");
   return s+s1+s2+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::null_statement() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::null_statement() {QCString s;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
       if (!hasError) {
+      
 s+=":";
       }
+      
       break;
       }
     default:
@@ -5555,35 +6500,42 @@ s+=":";
     }
     }
     if (!hasError) {
+    
     jj_consume_token(NULL_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return s+="null";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::numeric_literal() {QCString s;
-    if (jj_2_54(2147483647)) {
-      if (!hasError) {
+    if (jj_2_55(2147483647)) {if (!hasError) {
+      
       s = physical_literal();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case INTEGER:
       case DECIMAL_LITERAL:
-      case BASED_LITERAL:{
-        if (!hasError) {
+      case BASED_LITERAL:{if (!hasError) {
+        
         s = abstract_literal();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
@@ -5593,66 +6545,79 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::object_class() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       jj_consume_token(CONSTANT_T);
       }
       if (!hasError) {
+      
 return "constant";
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       jj_consume_token(SIGNAL_T);
       }
       if (!hasError) {
+      
 return "signal";
       }
+      
       break;
       }
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       jj_consume_token(VARIABLE_T);
       }
       if (!hasError) {
+      
 return "variable";
       }
+      
       break;
       }
-    case SHARED_T:{
-      if (!hasError) {
+    case SHARED_T:{if (!hasError) {
+      
       jj_consume_token(SHARED_T);
       }
       if (!hasError) {
+      
       jj_consume_token(VARIABLE_T);
       }
       if (!hasError) {
+      
 return "shared variable";
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       jj_consume_token(FILE_T);
       }
       if (!hasError) {
+      
 return "file";
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       jj_consume_token(TYPE_T);
       }
       if (!hasError) {
+      
 return "type";
       }
+      
       break;
       }
     default:
@@ -5661,25 +6626,27 @@ return "type";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::operator_symbol() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::operator_symbol() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(STRINGLITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-void VhdlParser::options() {
-    if (!hasError) {
+void VhdlParser::options() {if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GUARDED_T:{
-      if (!hasError) {
+    case GUARDED_T:{if (!hasError) {
+      
       jj_consume_token(GUARDED_T);
       }
+      
       break;
       }
     default:
@@ -5688,13 +6655,15 @@ void VhdlParser::options() {
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case INERTIAL_T:
     case REJECT_T:
-    case TRANSPORT_T:{
-      if (!hasError) {
+    case TRANSPORT_T:{if (!hasError) {
+      
       delay_mechanism();
       }
+      
       break;
       }
     default:
@@ -5702,42 +6671,52 @@ void VhdlParser::options() {
       ;
     }
     }
-}
+    
+  }
 
 
-void VhdlParser::package_body() {QCString s;
-    if (!hasError) {
+void VhdlParser::package_body() {QCString s;if (!hasError) {
+    
     jj_consume_token(PACKAGE_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BODY_T);
     }
     if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 lastCompound=current.get();
                         s.prepend("_");
                         addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
     }
     if (!hasError) {
+    
     package_body_declarative_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PACKAGE_T:{
-      if (!hasError) {
+    case PACKAGE_T:{if (!hasError) {
+      
       jj_consume_token(PACKAGE_T);
       }
       if (!hasError) {
+      
       jj_consume_token(BODY_T);
       }
+      
       break;
       }
     default:
@@ -5746,14 +6725,16 @@ lastCompound=current.get();
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -5762,10 +6743,12 @@ lastCompound=current.get();
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 lastCompound=0; genLabels.resize(0);
-}
+  }
 
 
 void VhdlParser::package_body_declarative_item() {
@@ -5773,67 +6756,77 @@ void VhdlParser::package_body_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       type_declaration();
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       subtype_declaration();
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       constant_declaration();
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       variable_declaration();
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       file_declaration();
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       alias_declaration();
       }
+      
       break;
       }
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       use_clause();
       }
+      
       break;
       }
     default:
       jj_la1[152] = jj_gen;
-      if (jj_2_55(3)) {
-        if (!hasError) {
+      if (jj_2_56(3)) {if (!hasError) {
+        
         group_template_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case GROUP_T:{
-          if (!hasError) {
+        case GROUP_T:{if (!hasError) {
+          
           group_declaration();
           }
+          
           break;
           }
         default:
@@ -5843,11 +6836,11 @@ void VhdlParser::package_body_declarative_item() {
         }
       }
     }
-}
+  }
 
 
-void VhdlParser::package_body_declarative_part() {
-    if (!hasError) {
+void VhdlParser::package_body_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -5869,27 +6862,32 @@ void VhdlParser::package_body_declarative_part() {
       default:
         jj_la1[154] = jj_gen;
         goto end_label_29;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       package_body_declarative_item();
       }
+      
     }
     end_label_29: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::package_declaration() {QCString s;
-    if (!hasError) {
+void VhdlParser::package_declaration() {QCString s;if (!hasError) {
+    
     jj_consume_token(PACKAGE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 lastCompound=current.get();
                           std::shared_ptr<Entry> clone=std::make_shared<Entry>(*current);
                           clone->section=Entry::NAMESPACE_SEC;
@@ -5902,17 +6900,21 @@ lastCompound=current.get();
                           addVhdlType(s,getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
     }
     if (!hasError) {
+    
     package_declarative_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PACKAGE_T:{
-      if (!hasError) {
+    case PACKAGE_T:{if (!hasError) {
+      
       jj_consume_token(PACKAGE_T);
       }
+      
       break;
       }
     default:
@@ -5921,14 +6923,16 @@ lastCompound=current.get();
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -5937,31 +6941,37 @@ lastCompound=current.get();
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 lastEntity=0;lastCompound=0; genLabels.resize(0);
-}
+  }
 
 
-void VhdlParser::geninter() {
-    if (!hasError) {
+void VhdlParser::geninter() {if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       gen_interface_list();
       }
       if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case GENERIC_T:{
-        if (!hasError) {
+      case GENERIC_T:{if (!hasError) {
+        
         gen_assoc_list();
         }
         if (!hasError) {
+        
         jj_consume_token(SEMI_T);
         }
+        
         break;
         }
       default:
@@ -5969,6 +6979,7 @@ void VhdlParser::geninter() {
         ;
       }
       }
+      
       break;
       }
     default:
@@ -5976,7 +6987,8 @@ void VhdlParser::geninter() {
       ;
     }
     }
-}
+    
+  }
 
 
 void VhdlParser::package_declarative_item() {
@@ -5984,113 +6996,130 @@ void VhdlParser::package_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       type_declaration();
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       subtype_declaration();
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       constant_declaration();
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       signal_declaration();
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       variable_declaration();
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       file_declaration();
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       alias_declaration();
       }
+      
       break;
       }
-    case COMPONENT_T:{
-      if (!hasError) {
+    case COMPONENT_T:{if (!hasError) {
+      
       component_declaration();
       }
+      
       break;
       }
     default:
       jj_la1[159] = jj_gen;
-      if (jj_2_56(2147483647)) {
-        if (!hasError) {
+      if (jj_2_57(2147483647)) {if (!hasError) {
+        
         attribute_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           attribute_specification();
           }
+          
           break;
           }
-        case DISCONNECT_T:{
-          if (!hasError) {
+        case DISCONNECT_T:{if (!hasError) {
+          
           disconnection_specification();
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           use_clause();
           }
+          
           break;
           }
         default:
           jj_la1[160] = jj_gen;
-          if (jj_2_57(3)) {
-            if (!hasError) {
+          if (jj_2_58(3)) {if (!hasError) {
+            
             group_template_declaration();
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               group_declaration();
               }
+              
               break;
               }
             default:
               jj_la1[161] = jj_gen;
-              if (jj_2_58(5)) {
-                if (!hasError) {
+              if (jj_2_59(5)) {if (!hasError) {
+                
                 package_instantiation_declaration();
                 }
+                
               } else {
                 switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-                case PACKAGE_T:{
-                  if (!hasError) {
+                case PACKAGE_T:{if (!hasError) {
+                  
                   package_declaration();
                   }
+                  
                   break;
                   }
                 default:
@@ -6104,11 +7133,11 @@ void VhdlParser::package_declarative_item() {
         }
       }
     }
-}
+  }
 
 
-void VhdlParser::package_declarative_part() {
-    if (!hasError) {
+void VhdlParser::package_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -6135,63 +7164,75 @@ void VhdlParser::package_declarative_part() {
       default:
         jj_la1[163] = jj_gen;
         goto end_label_30;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       package_declarative_item();
       }
+      
     }
     end_label_30: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::parameter_specification() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::parameter_specification() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IN_T);
     }
     if (!hasError) {
+    
     s1 = discrete_range();
     }
+    
 return s+" in "+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::physical_literal() {QCString s,s1;
-    if (!hasError) {
-    if (jj_2_59(2147483647)) {
-      if (!hasError) {
+QCString VhdlParser::physical_literal() {QCString s,s1;if (!hasError) {
+    
+    if (jj_2_60(2147483647)) {if (!hasError) {
+      
       s = abstract_literal();
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     s1 = name();
     }
+    
 s+=" ";s+=s1;s.prepend(" "); return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::physical_type_definition() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::physical_type_definition() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(UNITS_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
     if (!hasError) {
+    
 addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case BASIC_IDENTIFIER:
@@ -6202,28 +7243,33 @@ addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public)
       default:
         jj_la1[164] = jj_gen;
         goto end_label_31;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = secondary_unit_declaration();
       }
+      
     }
     end_label_31: ;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(UNITS_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -6231,126 +7277,156 @@ addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public)
       ;
     }
     }
+    
 return s+"%";
 assert(false);
-}
+  }
 
 
-void VhdlParser::port_clause() {
-    if (!hasError) {
+void VhdlParser::port_clause() {if (!hasError) {
+    
     jj_consume_token(PORT_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     port_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 currP=0;
-}
+  }
 
 
-QCString VhdlParser::port_list() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::port_list() {QCString s;if (!hasError) {
+    
     s = interface_list();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::port_map_aspect() {
-    if (!hasError) {
+void VhdlParser::port_map_aspect() {if (!hasError) {
+    
     jj_consume_token(PORT_T);
     }
     if (!hasError) {
+    
     jj_consume_token(MAP_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     association_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
-}
+    
+  }
 
 
 QCString VhdlParser::primary() {QCString s,s1;
-    if (jj_2_60(2147483647)) {
-      if (!hasError) {
+    if (jj_2_61(2147483647)) {if (!hasError) {
+      
       s = function_call();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_61(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_62(2147483647)) {if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s="("+s1+")"; return s;
       }
-    } else if (jj_2_62(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_63(2147483647)) {if (!hasError) {
+      
       s = qualified_expression();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_63(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_64(2147483647)) {if (!hasError) {
+      
       s = type_conversion();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_64(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_65(2147483647)) {if (!hasError) {
+      
       s = literal();
       }
       if (!hasError) {
+      
 s.prepend(" ");return s;
       }
-    } else if (jj_2_65(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_66(2147483647)) {if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case NEW_T:{
-        if (!hasError) {
+      case NEW_T:{if (!hasError) {
+        
         allocator();
         }
         if (!hasError) {
+        
 return "";
         }
+        
         break;
         }
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
         s = aggregate();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
@@ -6360,39 +7436,44 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
 void VhdlParser::primary_unit() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ENTITY_T:{
-      if (!hasError) {
+    case ENTITY_T:{if (!hasError) {
+      
       entity_declaration();
       }
+      
       break;
       }
-    case CONFIGURATION_T:{
-      if (!hasError) {
+    case CONFIGURATION_T:{if (!hasError) {
+      
       configuration_declaration();
       }
+      
       break;
       }
     default:
       jj_la1[167] = jj_gen;
-      if (jj_2_66(2147483647)) {
-        if (!hasError) {
+      if (jj_2_67(2147483647)) {if (!hasError) {
+        
         package_instantiation_declaration();
         }
-      } else if (jj_2_67(4)) {
-        if (!hasError) {
+        
+      } else if (jj_2_68(4)) {if (!hasError) {
+        
         interface_package_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case PACKAGE_T:{
-          if (!hasError) {
+        case PACKAGE_T:{if (!hasError) {
+          
           package_declaration();
           }
+          
           break;
           }
         default:
@@ -6402,28 +7483,33 @@ void VhdlParser::primary_unit() {
         }
       }
     }
-}
+  }
 
 
-QCString VhdlParser::procedure_call() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::procedure_call() {QCString s,s1;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = actual_parameter_part();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
       if (!hasError) {
+      
 s1.prepend("("); s1.append(")");
       }
+      
       break;
       }
     default:
@@ -6431,36 +7517,43 @@ s1.prepend("("); s1.append(")");
       ;
     }
     }
+    
 return s+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::procedure_call_statement() {QCString s,s1;
-    if (!hasError) {
-    if (jj_2_68(2)) {
-      if (!hasError) {
+QCString VhdlParser::procedure_call_statement() {QCString s,s1;if (!hasError) {
+    
+    if (jj_2_69(2)) {if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
       if (!hasError) {
+      
 s+=":";
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     s1 = procedure_call();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return s+s1+";";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::process_declarative_item() {QCString s;
@@ -6468,117 +7561,141 @@ QCString VhdlParser::process_declarative_item() {QCString s;
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
       if (!hasError) {
+      
 return "";
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       s = type_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       s = subtype_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       s = constant_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       s = variable_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       s = file_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       s = alias_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
       jj_la1[170] = jj_gen;
-      if (jj_2_69(3)) {
-        if (!hasError) {
+      if (jj_2_70(3)) {if (!hasError) {
+        
         s = attribute_declaration();
         }
         if (!hasError) {
+        
 return s;
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           s = attribute_specification();
           }
           if (!hasError) {
+          
 return s;
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           s = use_clause();
           }
           if (!hasError) {
+          
 return s;
           }
+          
           break;
           }
         default:
           jj_la1[171] = jj_gen;
-          if (jj_2_70(3)) {
-            if (!hasError) {
+          if (jj_2_71(3)) {if (!hasError) {
+            
             s = group_template_declaration();
             }
             if (!hasError) {
+            
 return s;
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               s = group_declaration();
               }
               if (!hasError) {
+              
 return s;
               }
+              
               break;
               }
             default:
@@ -6591,11 +7708,11 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::process_declarative_part() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::process_declarative_part() {QCString s,s1;if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -6618,32 +7735,37 @@ QCString VhdlParser::process_declarative_part() {QCString s,s1;
       default:
         jj_la1[173] = jj_gen;
         goto end_label_32;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = process_declarative_item();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     }
     end_label_32: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;
-    if (!hasError) {
+void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -6652,11 +7774,13 @@ void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case POSTPONED_T:{
-      if (!hasError) {
+    case POSTPONED_T:{if (!hasError) {
+      
       jj_consume_token(POSTPONED_T);
       }
+      
       break;
       }
     default:
@@ -6665,34 +7789,40 @@ void VhdlParser::process_statement() {QCString s,s1,s2;Token *tok=0;
     }
     }
     if (!hasError) {
+    
 currP=VhdlDocGen::PROCESS;
                current->startLine=getLine();
                current->bodyLine=getLine();
     }
     if (!hasError) {
+    
     jj_consume_token(PROCESS_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case ALL_T:{
-        if (!hasError) {
+      case ALL_T:{if (!hasError) {
+        
         tok = jj_consume_token(ALL_T);
         }
+        
         break;
         }
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         s1 = sensitivity_list();
         }
+        
         break;
         }
       default:
@@ -6702,8 +7832,10 @@ currP=VhdlDocGen::PROCESS;
       }
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
+      
       break;
       }
     default:
@@ -6712,11 +7844,13 @@ currP=VhdlDocGen::PROCESS;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       jj_consume_token(IS_T);
       }
+      
       break;
       }
     default:
@@ -6725,28 +7859,35 @@ currP=VhdlDocGen::PROCESS;
     }
     }
     if (!hasError) {
+    
     s2 = process_declarative_part();
     }
     if (!hasError) {
+    
 if (s2.data())
                   FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s2.data(),0);
                 FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0);
     }
     if (!hasError) {
+    
     jj_consume_token(BEGIN_T);
     }
     if (!hasError) {
+    
     process_statement_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case POSTPONED_T:{
-      if (!hasError) {
+    case POSTPONED_T:{if (!hasError) {
+      
       jj_consume_token(POSTPONED_T);
       }
+      
       break;
       }
     default:
@@ -6755,15 +7896,18 @@ if (s2.data())
     }
     }
     if (!hasError) {
+    
     jj_consume_token(PROCESS_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -6772,8 +7916,10 @@ if (s2.data())
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(s.isEmpty())
    currName=VhdlDocGen::getProcessNumber();
    else
@@ -6789,11 +7935,11 @@ if(s.isEmpty())
   createFlow();
    currName="";
    newEntry();
-}
+  }
 
 
-void VhdlParser::process_statement_part() {
-    if (!hasError) {
+void VhdlParser::process_statement_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -6820,49 +7966,60 @@ void VhdlParser::process_statement_part() {
       default:
         jj_la1[181] = jj_gen;
         goto end_label_33;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       sequential_statement();
       }
+      
     }
     end_label_33: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::qualified_expression() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::qualified_expression() {QCString s,s1;if (!hasError) {
+    
     s1 = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(APOSTROPHE_T);
     }
     if (!hasError) {
+    
 s=s1+"'";
     }
     if (!hasError) {
-    if (jj_2_71(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_72(2147483647)) {if (!hasError) {
+      
       s1 = aggregate();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
         s1 = expression();
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
         if (!hasError) {
+        
 s+="(";s+=s1;s+=")";
         }
+        
         break;
         }
       default:
@@ -6872,61 +8029,72 @@ s+="(";s+=s1;s+=")";
       }
     }
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::range() {QCString s,s1,s2;
-    if (jj_2_72(2147483647)) {
-      if (!hasError) {
+    if (jj_2_73(2147483647)) {if (!hasError) {
+      
       s = simple_expression();
       }
       if (!hasError) {
+      
       s1 = direction();
       }
       if (!hasError) {
+      
       s2 = simple_expression();
       }
       if (!hasError) {
+      
 return s+" "+s1+" "+s2;
       }
-    } else if (jj_2_73(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_74(2147483647)) {if (!hasError) {
+      
       s = attribute_name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::range_constraint() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::range_constraint() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(RANGE_T);
     }
     if (!hasError) {
+    
     s = range();
     }
+    
 return " range "+s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::record_type_definition() {
-    if (!hasError) {
+void VhdlParser::record_type_definition() {if (!hasError) {
+    
     jj_consume_token(RECORD_T);
     }
     if (!hasError) {
-    while (!hasError) {
-      if (!hasError) {
+    
+    while (!hasError) {if (!hasError) {
+      
       element_declaration();
       }
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case BASIC_IDENTIFIER:
       case EXTENDED_CHARACTER:{
@@ -6941,20 +8109,24 @@ void VhdlParser::record_type_definition() {
     end_label_34: ;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(RECORD_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       name();
       }
+      
       break;
       }
     default:
@@ -6962,27 +8134,31 @@ void VhdlParser::record_type_definition() {
       ;
     }
     }
-}
+    
+  }
 
 
-QCString VhdlParser::relation() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::relation() {QCString s,s1,s2;if (!hasError) {
+    
     s = shift_expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case LESSTHAN_T:
     case GREATERTHAN_T:
     case LT_T:
     case GT_T:
     case EQU_T:
-    case NOTEQU_T:{
-      if (!hasError) {
+    case NOTEQU_T:{if (!hasError) {
+      
       s1 = relation_operator();
       }
       if (!hasError) {
+      
       s2 = shift_expression();
       }
+      
       break;
       }
     default:
@@ -6990,65 +8166,78 @@ QCString VhdlParser::relation() {QCString s,s1,s2;
       ;
     }
     }
+    
 return s+s1+s2;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::relation_operator() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LT_T:{
-      if (!hasError) {
+    case LT_T:{if (!hasError) {
+      
       jj_consume_token(LT_T);
       }
       if (!hasError) {
+      
 return "<";
       }
+      
       break;
       }
-    case GT_T:{
-      if (!hasError) {
+    case GT_T:{if (!hasError) {
+      
       jj_consume_token(GT_T);
       }
       if (!hasError) {
+      
 return ">";
       }
+      
       break;
       }
-    case EQU_T:{
-      if (!hasError) {
+    case EQU_T:{if (!hasError) {
+      
       jj_consume_token(EQU_T);
       }
       if (!hasError) {
+      
 return "=";
       }
+      
       break;
       }
-    case GREATERTHAN_T:{
-      if (!hasError) {
+    case GREATERTHAN_T:{if (!hasError) {
+      
       jj_consume_token(GREATERTHAN_T);
       }
       if (!hasError) {
+      
 return ">=";
       }
+      
       break;
       }
-    case LESSTHAN_T:{
-      if (!hasError) {
+    case LESSTHAN_T:{if (!hasError) {
+      
       jj_consume_token(LESSTHAN_T);
       }
       if (!hasError) {
+      
 return "<=";
       }
+      
       break;
       }
-    case NOTEQU_T:{
-      if (!hasError) {
+    case NOTEQU_T:{if (!hasError) {
+      
       jj_consume_token(NOTEQU_T);
       }
       if (!hasError) {
+      
 return "/=";
       }
+      
       break;
       }
     default:
@@ -7057,20 +8246,22 @@ return "/=";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       t = jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -7079,20 +8270,25 @@ QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2
     }
     }
     if (!hasError) {
+    
     jj_consume_token(REPORT_T);
     }
     if (!hasError) {
+    
     s1 = expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case SEVERITY_T:{
-      if (!hasError) {
+    case SEVERITY_T:{if (!hasError) {
+      
       t1 = jj_consume_token(SEVERITY_T);
       }
       if (!hasError) {
+      
       s2 = expression();
       }
+      
       break;
       }
     default:
@@ -7101,30 +8297,35 @@ QCString VhdlParser::report_statement() {Token *t=0;Token *t1=0;QCString s,s1,s2
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(t) s.append(":");
         s1.prepend(" report ");
         if(t1) s2.prepend(" severity ");
         return s+s1+s2+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::return_statement() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::return_statement() {QCString s,s1;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       jj_consume_token(COLON_T);
       }
       if (!hasError) {
+      
 s+=":";
       }
+      
       break;
       }
     default:
@@ -7133,9 +8334,11 @@ s+=":";
     }
     }
     if (!hasError) {
+    
     jj_consume_token(RETURN_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case ABS_T:
     case NEW_T:
@@ -7152,10 +8355,11 @@ s+=":";
     case CHARACTER_LITERAL:
     case DECIMAL_LITERAL:
     case BASED_LITERAL:
-    case BIT_STRING_LITERAL:{
-      if (!hasError) {
+    case BIT_STRING_LITERAL:{if (!hasError) {
+      
       s1 = expression();
       }
+      
       break;
       }
     default:
@@ -7164,40 +8368,48 @@ s+=":";
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return s+" return "+s1+";";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::scalar_type_definition() {QCString s,s1;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       s = enumeration_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case RANGE_T:{
-      if (!hasError) {
+    case RANGE_T:{if (!hasError) {
+      
       s = range_constraint();
       }
       if (!hasError) {
-      if (jj_2_74(2147483647)) {
-        if (!hasError) {
+      
+      if (jj_2_75(2147483647)) {if (!hasError) {
+        
         s1 = physical_type_definition();
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
+      
 return s+" "+s1+"%";
       }
+      
       break;
       }
     default:
@@ -7206,21 +8418,23 @@ return s+" "+s1+"%";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 void VhdlParser::secondary_unit() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ARCHITECTURE_T:{
-      if (!hasError) {
+    case ARCHITECTURE_T:{if (!hasError) {
+      
       architecture_body();
       }
+      
       break;
       }
-    case PACKAGE_T:{
-      if (!hasError) {
+    case PACKAGE_T:{if (!hasError) {
+      
       package_body();
       }
+      
       break;
       }
     default:
@@ -7228,84 +8442,102 @@ void VhdlParser::secondary_unit() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-QCString VhdlParser::secondary_unit_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::secondary_unit_declaration() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(EQU_T);
     }
     if (!hasError) {
+    
     s1 = physical_literal();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 //printf("\n %s %s [%d]",s.data(),s1.data(),getLine());
   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
 
   return s+"="+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::selected_name() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::selected_name() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(DOT_T);
     }
     if (!hasError) {
+    
     s1 = suffix();
     }
+    
 return s+"."+s1;
 assert(false);
-}
+  }
 
 
-void VhdlParser::selected_signal_assignment() {
-    if (!hasError) {
+void VhdlParser::selected_signal_assignment() {if (!hasError) {
+    
     jj_consume_token(WITH_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SELECT_T);
     }
     if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     options();
     }
     if (!hasError) {
+    
     selected_waveforms();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::selected_waveforms() {
-    if (!hasError) {
+void VhdlParser::selected_waveforms() {if (!hasError) {
+    
     waveform();
     }
     if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     choices();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -7315,43 +8547,51 @@ void VhdlParser::selected_waveforms() {
       default:
         jj_la1[193] = jj_gen;
         goto end_label_35;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       waveform();
       }
       if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       choices();
       }
+      
     }
     end_label_35: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::sensitivity_clause() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::sensitivity_clause() {QCString s;if (!hasError) {
+    
     jj_consume_token(ON_T);
     }
     if (!hasError) {
+    
     s = sensitivity_list();
     }
+    
 s.prepend(" on ");
   return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::sensitivity_list() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::sensitivity_list() {QCString s,s1;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -7361,142 +8601,175 @@ QCString VhdlParser::sensitivity_list() {QCString s,s1;
       default:
         jj_la1[194] = jj_gen;
         goto end_label_36;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = name();
       }
       if (!hasError) {
+      
 s+=",";s+=s1;
       }
+      
     }
     end_label_36: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::sequence_of_statement() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::sequence_of_statement() {QCString s,s1;if (!hasError) {
+    
     while (!hasError) {
-      if (jj_2_75(3)) {
+      if (jj_2_76(3)) {
         ;
       } else {
         goto end_label_37;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = sequential_statement();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     }
     end_label_37: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::sequential_statement() {QCString s;
-    if (jj_2_76(2147483647)) {
-      if (!hasError) {
+    if (jj_2_77(2147483647)) {if (!hasError) {
+      
       s = signal_assignment_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_77(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_78(3)) {if (!hasError) {
+      
       s = assertion_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_78(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_79(3)) {if (!hasError) {
+      
       s = report_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_79(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_80(3)) {if (!hasError) {
+      
       s = wait_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_80(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_81(2147483647)) {if (!hasError) {
+      
       s = variable_assignment_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_81(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_82(3)) {if (!hasError) {
+      
       s = procedure_call_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
-    } else if (jj_2_82(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_83(3)) {if (!hasError) {
+      
       if_statement();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_83(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_84(3)) {if (!hasError) {
+      
       case_statement();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_84(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_85(3)) {if (!hasError) {
+      
       loop_statement();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_85(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_86(3)) {if (!hasError) {
+      
       s = next_statement();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_86(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_87(3)) {if (!hasError) {
+      
       s = exit_statement();
       }
       if (!hasError) {
+      
 return s;
       }
-    } else if (jj_2_87(3)) {
-      if (!hasError) {
+      
+    } else if (jj_2_88(3)) {if (!hasError) {
+      
       s = return_statement();
       }
       if (!hasError) {
+      
 FlowChart::addFlowChart(FlowChart::RETURN_NO,s.data(),0);return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case NULL_T:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         s = null_statement();
         }
         if (!hasError) {
+        
 FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
         }
+        
         break;
         }
       default:
@@ -7506,27 +8779,30 @@ FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::shift_expression() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::shift_expression() {QCString s,s1,s2;if (!hasError) {
+    
     s = simple_expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case ROL_T:
     case ROR_T:
     case SLA_T:
     case SLL_T:
     case SRA_T:
-    case SRL_T:{
-      if (!hasError) {
+    case SRL_T:{if (!hasError) {
+      
       s1 = shift_operator();
       }
       if (!hasError) {
+      
       s2 = simple_expression();
       }
+      
       break;
       }
     default:
@@ -7534,65 +8810,78 @@ QCString VhdlParser::shift_expression() {QCString s,s1,s2;
       ;
     }
     }
+    
 return s+s1+s2;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::shift_operator() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case SLL_T:{
-      if (!hasError) {
+    case SLL_T:{if (!hasError) {
+      
       jj_consume_token(SLL_T);
       }
       if (!hasError) {
+      
 return "sll";
       }
+      
       break;
       }
-    case SRL_T:{
-      if (!hasError) {
+    case SRL_T:{if (!hasError) {
+      
       jj_consume_token(SRL_T);
       }
       if (!hasError) {
+      
 return "srl";
       }
+      
       break;
       }
-    case SLA_T:{
-      if (!hasError) {
+    case SLA_T:{if (!hasError) {
+      
       jj_consume_token(SLA_T);
       }
       if (!hasError) {
+      
 return "sla";
       }
+      
       break;
       }
-    case SRA_T:{
-      if (!hasError) {
+    case SRA_T:{if (!hasError) {
+      
       jj_consume_token(SRA_T);
       }
       if (!hasError) {
+      
 return "sra";
       }
+      
       break;
       }
-    case ROL_T:{
-      if (!hasError) {
+    case ROL_T:{if (!hasError) {
+      
       jj_consume_token(ROL_T);
       }
       if (!hasError) {
+      
 return "rol";
       }
+      
       break;
       }
-    case ROR_T:{
-      if (!hasError) {
+    case ROR_T:{if (!hasError) {
+      
       jj_consume_token(ROR_T);
       }
       if (!hasError) {
+      
 return "ror";
       }
+      
       break;
       }
     default:
@@ -7601,27 +8890,31 @@ return "ror";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::sign() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PLUS_T:{
-      if (!hasError) {
+    case PLUS_T:{if (!hasError) {
+      
       jj_consume_token(PLUS_T);
       }
       if (!hasError) {
+      
 return "+";
       }
+      
       break;
       }
-    case MINUS_T:{
-      if (!hasError) {
+    case MINUS_T:{if (!hasError) {
+      
       jj_consume_token(MINUS_T);
       }
       if (!hasError) {
+      
 return "-";
       }
+      
       break;
       }
     default:
@@ -7630,60 +8923,71 @@ return "-";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::signal_assignment_statement() {QCString s,s1,s2,s3;
-    if (jj_2_89(2147483647)) {
-      if (!hasError) {
+    if (jj_2_90(2147483647)) {if (!hasError) {
+      
       conditional_signal_assignment_wave();
       }
       if (!hasError) {
+      
 return "";
       }
-    } else if (jj_2_90(2147483647)) {
-      if (!hasError) {
+      
+    } else if (jj_2_91(2147483647)) {if (!hasError) {
+      
       selected_signal_assignment_wave();
       }
       if (!hasError) {
+      
 return "";
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case LPAREN_T:
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
-        if (jj_2_88(2)) {
-          if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
+        if (jj_2_89(2)) {if (!hasError) {
+          
           s = identifier();
           }
           if (!hasError) {
+          
           jj_consume_token(COLON_T);
           }
           if (!hasError) {
+          
 s+=":";
           }
+          
         } else {
           ;
         }
         }
         if (!hasError) {
+        
         s1 = target();
         }
         if (!hasError) {
+        
         jj_consume_token(LESSTHAN_T);
         }
         if (!hasError) {
+        
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case INERTIAL_T:
         case REJECT_T:
-        case TRANSPORT_T:{
-          if (!hasError) {
+        case TRANSPORT_T:{if (!hasError) {
+          
           s2 = delay_mechanism();
           }
+          
           break;
           }
         default:
@@ -7692,14 +8996,18 @@ s+=":";
         }
         }
         if (!hasError) {
+        
         s3 = waveform();
         }
         if (!hasError) {
+        
         jj_consume_token(SEMI_T);
         }
         if (!hasError) {
+        
 return s+s1+"<="+s2+s3+";";
         }
+        
         break;
         }
       default:
@@ -7709,36 +9017,42 @@ return s+s1+"<="+s2+s3+";";
       }
     }
 assert(false);
-}
+  }
 
 
-void VhdlParser::semi() {
-    if (!hasError) {
+void VhdlParser::semi() {if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;
-    if (!hasError) {
+void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;if (!hasError) {
+    
     jj_consume_token(SIGNAL_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BUS_T:
-    case REGISTER_T:{
-      if (!hasError) {
+    case REGISTER_T:{if (!hasError) {
+      
       s2 = signal_kind();
       }
+      
       break;
       }
     default:
@@ -7747,14 +9061,17 @@ void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case VARASSIGN_T:{
-      if (!hasError) {
+    case VARASSIGN_T:{if (!hasError) {
+      
       tok = jj_consume_token(VARASSIGN_T);
       }
       if (!hasError) {
+      
       s3 = expression();
       }
+      
       break;
       }
     default:
@@ -7763,33 +9080,39 @@ void VhdlParser::signal_declaration() {Token* tok=0;QCString s,s1,s2,s3,s4;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(tok)
       s3.prepend(":=");
      s4=s1+s2+s3;
      addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
-}
+  }
 
 
 QCString VhdlParser::signal_kind() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case REGISTER_T:{
-      if (!hasError) {
+    case REGISTER_T:{if (!hasError) {
+      
       jj_consume_token(REGISTER_T);
       }
       if (!hasError) {
+      
 return "register";
       }
+      
       break;
       }
-    case BUS_T:{
-      if (!hasError) {
+    case BUS_T:{if (!hasError) {
+      
       jj_consume_token(BUS_T);
       }
       if (!hasError) {
+      
 return "bus";
       }
+      
       break;
       }
     default:
@@ -7798,7 +9121,7 @@ return "bus";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::signal_list() {QCString s,s1;
@@ -7806,11 +9129,12 @@ QCString VhdlParser::signal_list() {QCString s,s1;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
       while (!hasError) {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case COMMA_T:{
@@ -7820,37 +9144,45 @@ QCString VhdlParser::signal_list() {QCString s,s1;
         default:
           jj_la1[204] = jj_gen;
           goto end_label_38;
-        }
-        if (!hasError) {
+        }if (!hasError) {
+        
         jj_consume_token(COMMA_T);
         }
         if (!hasError) {
+        
         s1 = name();
         }
         if (!hasError) {
+        
 s+=",";s+=s1;
         }
+        
       }
       end_label_38: ;
       }
+      
       break;
       }
-    case OTHER_T:{
-      if (!hasError) {
+    case OTHER_T:{if (!hasError) {
+      
       jj_consume_token(OTHER_T);
       }
       if (!hasError) {
+      
 return "other";
       }
+      
       break;
       }
-    case ALL_T:{
-      if (!hasError) {
+    case ALL_T:{if (!hasError) {
+      
       jj_consume_token(ALL_T);
       }
       if (!hasError) {
+      
 return "all";
       }
+      
       break;
       }
     default:
@@ -7859,23 +9191,25 @@ return "all";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::signature() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::signature() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(LBRACKET_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
       while (!hasError) {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case COMMA_T:{
@@ -7885,19 +9219,23 @@ QCString VhdlParser::signature() {QCString s,s1,s2;
         default:
           jj_la1[206] = jj_gen;
           goto end_label_39;
-        }
-        if (!hasError) {
+        }if (!hasError) {
+        
         jj_consume_token(COMMA_T);
         }
         if (!hasError) {
+        
         s1 = name();
         }
         if (!hasError) {
+        
 s+=",";s+=s1;
         }
+        
       }
       end_label_39: ;
       }
+      
       break;
       }
     default:
@@ -7906,17 +9244,21 @@ s+=",";s+=s1;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case RETURN_T:{
-      if (!hasError) {
+    case RETURN_T:{if (!hasError) {
+      
       jj_consume_token(RETURN_T);
       }
       if (!hasError) {
+      
       s1 = name();
       }
       if (!hasError) {
+      
 s+="return ";s+=s1;
       }
+      
       break;
       }
     default:
@@ -7925,21 +9267,24 @@ s+="return ";s+=s1;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(RBRACKET_T);
     }
+    
 s1="["+s+"]";return s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::simple_expression() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::simple_expression() {QCString s,s1,s2;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case PLUS_T:
-    case MINUS_T:{
-      if (!hasError) {
+    case MINUS_T:{if (!hasError) {
+      
       s = sign();
       }
+      
       break;
       }
     default:
@@ -7948,78 +9293,93 @@ QCString VhdlParser::simple_expression() {QCString s,s1,s2;
     }
     }
     if (!hasError) {
+    
     s1 = term();
     }
     if (!hasError) {
+    
 s+=s1;
     }
     if (!hasError) {
+    
     while (!hasError) {
-      if (jj_2_91(2147483647)) {
+      if (jj_2_92(2147483647)) {
         ;
       } else {
         goto end_label_40;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = adding_operator();
       }
       if (!hasError) {
+      
       s2 = term();
       }
       if (!hasError) {
+      
 s+=s1;s+=s2;
       }
+      
     }
     end_label_40: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-void VhdlParser::simple_name() {
-    if (!hasError) {
+void VhdlParser::simple_name() {if (!hasError) {
+    
     name();
     }
-}
+    
+  }
 
 
-QCString VhdlParser::slice_name() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::slice_name() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s1 = discrete_range();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return s+"("+s1+")";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::string_literal() {Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::string_literal() {Token *tok=0;if (!hasError) {
+    
     tok = jj_consume_token(STRINGLITERAL);
     }
+    
 return tok->image.c_str();
 assert(false);
-}
+  }
 
 
-void VhdlParser::subprogram_body() {QCString s;
-    if (!hasError) {
+void VhdlParser::subprogram_body() {QCString s;if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     //try{
      s = subprogram_declarative_part();
     }
     if (!hasError) {
+    
 if (s.data())
       {
         FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s,0);
@@ -8027,21 +9387,26 @@ if (s.data())
       FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0);
     }
     if (!hasError) {
+    
     jj_consume_token(BEGIN_T);
     }
     if (!hasError) {
+    
     subprogram_statement_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case FUNCTION_T:
-    case PROCEDURE_T:{
-      if (!hasError) {
+    case PROCEDURE_T:{if (!hasError) {
+      
       subprogram_kind();
       }
+      
       break;
       }
     default:
@@ -8050,13 +9415,15 @@ if (s.data())
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       designator();
       }
+      
       break;
       }
     default:
@@ -8065,34 +9432,40 @@ if (s.data())
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 tempEntry->endBodyLine=getLine(END_T);
       createFlow();
       currP=0;
-}
+  }
 
 
 void VhdlParser::subprogram_declaration() {
-    if (jj_2_92(2147483647)) {
-      if (!hasError) {
+    if (jj_2_93(2147483647)) {if (!hasError) {
+      
       subprogram_instantiation_declaration();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case FUNCTION_T:
       case IMPURE_T:
       case PROCEDURE_T:
-      case PURE_T:{
-        if (!hasError) {
+      case PURE_T:{if (!hasError) {
+        
         subprogram_specification();
         }
         if (!hasError) {
+        
         subprogram_1();
         }
         if (!hasError) {
+        
 currP=0;
         }
+        
         break;
         }
       default:
@@ -8101,21 +9474,23 @@ currP=0;
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
 void VhdlParser::subprogram_1() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       subprogram_body();
       }
+      
       break;
       }
-    case SEMI_T:{
-      if (!hasError) {
+    case SEMI_T:{if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
+      
       break;
       }
     default:
@@ -8123,7 +9498,7 @@ void VhdlParser::subprogram_1() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
 QCString VhdlParser::subprogram_declarative_item() {QCString s;
@@ -8131,126 +9506,152 @@ QCString VhdlParser::subprogram_declarative_item() {QCString s;
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
       if (!hasError) {
+      
 return "";
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       s = type_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       subprogram_body();
       }
       if (!hasError) {
+      
 return "";
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       s = subtype_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       s = constant_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       s = variable_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       s = file_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       s = alias_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
       jj_la1[214] = jj_gen;
-      if (jj_2_93(2147483647)) {
-        if (!hasError) {
+      if (jj_2_94(2147483647)) {if (!hasError) {
+        
         s = attribute_declaration();
         }
         if (!hasError) {
+        
 return s;
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           s = attribute_specification();
           }
           if (!hasError) {
+          
 return s;
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           s = use_clause();
           }
           if (!hasError) {
+          
 return s;
           }
+          
           break;
           }
         default:
           jj_la1[215] = jj_gen;
-          if (jj_2_94(3)) {
-            if (!hasError) {
+          if (jj_2_95(3)) {if (!hasError) {
+            
             s = group_template_declaration();
             }
             if (!hasError) {
+            
 return s;
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               s = group_declaration();
               }
               if (!hasError) {
+              
 return s;
               }
+              
               break;
               }
             default:
@@ -8263,11 +9664,11 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::subprogram_declarative_part() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::subprogram_declarative_part() {QCString s,s1;if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -8291,33 +9692,38 @@ QCString VhdlParser::subprogram_declarative_part() {QCString s,s1;
       default:
         jj_la1[217] = jj_gen;
         goto end_label_41;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = subprogram_declarative_item();
       }
       if (!hasError) {
+      
 s+=s1;
       }
+      
     }
     end_label_41: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
 void VhdlParser::subprogram_kind() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case FUNCTION_T:{
-      if (!hasError) {
+    case FUNCTION_T:{if (!hasError) {
+      
       jj_consume_token(FUNCTION_T);
       }
+      
       break;
       }
-    case PROCEDURE_T:{
-      if (!hasError) {
+    case PROCEDURE_T:{if (!hasError) {
+      
       jj_consume_token(PROCEDURE_T);
       }
+      
       break;
       }
     default:
@@ -8325,19 +9731,21 @@ void VhdlParser::subprogram_kind() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
 void VhdlParser::subprogram_specification() {QCString s;Token *tok=0;Token *t;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PROCEDURE_T:{
-      if (!hasError) {
+    case PROCEDURE_T:{if (!hasError) {
+      
       jj_consume_token(PROCEDURE_T);
       }
       if (!hasError) {
+      
       s = designator();
       }
       if (!hasError) {
+      
 currP=VhdlDocGen::PROCEDURE;
               createFunction(s.data(),currP,0);
               tempEntry=current.get();
@@ -8345,23 +9753,29 @@ currP=VhdlDocGen::PROCEDURE;
                current->bodyLine=getLine(PROCEDURE_T);
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
 param_sec=PARAM_SEC;
         }
         if (!hasError) {
+        
         interface_list();
         }
         if (!hasError) {
+        
 param_sec=0;
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
+        
         break;
         }
       default:
@@ -8370,50 +9784,59 @@ param_sec=0;
       }
       }
       if (!hasError) {
-      if (jj_2_95(2)) {
-        if (!hasError) {
+      
+      if (jj_2_96(2)) {if (!hasError) {
+        
         gen_interface_list();
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
-      if (jj_2_96(2)) {
-        if (!hasError) {
+      
+      if (jj_2_97(2)) {if (!hasError) {
+        
         gen_assoc_list();
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
+      
       param();
       }
       if (!hasError) {
+      
 newEntry();
       }
+      
       break;
       }
     case FUNCTION_T:
     case IMPURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case IMPURE_T:
-      case PURE_T:{
-        if (!hasError) {
+      case PURE_T:{if (!hasError) {
+        
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case PURE_T:{
-          if (!hasError) {
+        case PURE_T:{if (!hasError) {
+          
           tok = jj_consume_token(PURE_T);
           }
+          
           break;
           }
-        case IMPURE_T:{
-          if (!hasError) {
+        case IMPURE_T:{if (!hasError) {
+          
           tok = jj_consume_token(IMPURE_T);
           }
+          
           break;
           }
         default:
@@ -8422,6 +9845,7 @@ newEntry();
           errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
         }
         }
+        
         break;
         }
       default:
@@ -8430,12 +9854,15 @@ newEntry();
       }
       }
       if (!hasError) {
+      
       t = jj_consume_token(FUNCTION_T);
       }
       if (!hasError) {
+      
       s = designator();
       }
       if (!hasError) {
+      
 currP=VhdlDocGen::FUNCTION;
      if(tok)
      createFunction(tok->image.c_str(),currP,s.data());
@@ -8446,23 +9873,29 @@ currP=VhdlDocGen::FUNCTION;
       current->bodyLine=getLine(FUNCTION_T);
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case LPAREN_T:{
-        if (!hasError) {
+      case LPAREN_T:{if (!hasError) {
+        
 param_sec=PARAM_SEC;
         }
         if (!hasError) {
+        
         jj_consume_token(LPAREN_T);
         }
         if (!hasError) {
+        
         formal_parameter_list();
         }
         if (!hasError) {
+        
         jj_consume_token(RPAREN_T);
         }
         if (!hasError) {
+        
 param_sec=0;
         }
+        
         break;
         }
       default:
@@ -8471,16 +9904,20 @@ param_sec=0;
       }
       }
       if (!hasError) {
+      
       jj_consume_token(RETURN_T);
       }
       if (!hasError) {
+      
       s = type_mark();
       }
       if (!hasError) {
+      
 tempEntry=current.get();
                 current->type=s;
                 newEntry();
       }
+      
       break;
       }
     default:
@@ -8488,11 +9925,11 @@ tempEntry=current.get();
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::subprogram_statement_part() {
-    if (!hasError) {
+void VhdlParser::subprogram_statement_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -8519,100 +9956,120 @@ void VhdlParser::subprogram_statement_part() {
       default:
         jj_la1[224] = jj_gen;
         goto end_label_42;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       sequential_statement();
       }
+      
     }
     end_label_42: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::subtype_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::subtype_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(SUBTYPE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
   return " subtype "+s+" is "+s1+";";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::subtype_indication() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::subtype_indication() {QCString s,s1,s2;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
-    if (jj_2_97(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_98(2147483647)) {if (!hasError) {
+      
       s1 = name();
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
-    if (jj_2_98(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_99(2147483647)) {if (!hasError) {
+      
       s2 = constraint();
       }
+      
     } else {
       ;
     }
     }
+    
 return s+" "+s1+" "+s2;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::suffix() {QCString s;
-    if (jj_2_99(2147483647)) {
-      if (!hasError) {
+    if (jj_2_100(2147483647)) {if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case CHARACTER_LITERAL:{
-        if (!hasError) {
+      case CHARACTER_LITERAL:{if (!hasError) {
+        
         s = character_literal();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
-      case STRINGLITERAL:{
-        if (!hasError) {
+      case STRINGLITERAL:{if (!hasError) {
+        
         s = operator_symbol();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
-      case ALL_T:{
-        if (!hasError) {
+      case ALL_T:{if (!hasError) {
+        
         jj_consume_token(ALL_T);
         }
         if (!hasError) {
+        
 return " all ";
         }
+        
         break;
         }
       default:
@@ -8622,7 +10079,7 @@ return " all ";
       }
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::target() {QCString s;
@@ -8630,22 +10087,26 @@ QCString VhdlParser::target() {QCString s;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       s = aggregate();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -8654,84 +10115,99 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::term() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::term() {QCString s,s1,s2;if (!hasError) {
+    
     s = factor();
     }
     if (!hasError) {
+    
     while (!hasError) {
-      if (jj_2_100(2)) {
+      if (jj_2_101(2)) {
         ;
       } else {
         goto end_label_43;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = multiplying_operation();
       }
       if (!hasError) {
+      
       s2 = factor();
       }
       if (!hasError) {
+      
 s+=s1;s+=s2;
       }
+      
     }
     end_label_43: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::timeout_clause() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::timeout_clause() {QCString s;if (!hasError) {
+    
     jj_consume_token(FOR_T);
     }
     if (!hasError) {
+    
     s = expression();
     }
+    
 return " for "+s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::type_conversion() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::type_conversion() {QCString s,s1;if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s1 = expression();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
+    
 return s+"("+s1+")";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::type_declaration() {QCString s;
-    if (jj_2_101(3)) {
-      if (!hasError) {
+    if (jj_2_102(3)) {if (!hasError) {
+      
       s = full_type_declaration();
       }
       if (!hasError) {
+      
 return s;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case TYPE_T:{
-        if (!hasError) {
+      case TYPE_T:{if (!hasError) {
+        
         s = incomplete_type_declaration();
         }
         if (!hasError) {
+        
 return s;
         }
+        
         break;
         }
       default:
@@ -8741,68 +10217,80 @@ return s;
       }
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::type_definition() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case RANGE_T:
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       //try{
       s = scalar_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     case ARRAY_T:
-    case RECORD_T:{
-      if (!hasError) {
+    case RECORD_T:{if (!hasError) {
+      
       s = composite_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case ACCESS_T:{
-      if (!hasError) {
+    case ACCESS_T:{if (!hasError) {
+      
       s = access_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       s = file_type_definition();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
       jj_la1[228] = jj_gen;
-      if (jj_2_102(2)) {
-        if (!hasError) {
+      if (jj_2_103(2)) {if (!hasError) {
+        
         protected_type_body();
         }
         if (!hasError) {
+        
 return "";
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case PROTECTED_T:{
-          if (!hasError) {
+        case PROTECTED_T:{if (!hasError) {
+          
           protected_type_declaration();
           }
           if (!hasError) {
+          
 return "";
           }
+          
           break;
           }
         default:
@@ -8813,29 +10301,33 @@ return "";
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::type_mark() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::type_mark() {QCString s;if (!hasError) {
+    
     s = name();
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::unconstraint_array_definition() {QCString s,s1,s2,s3;
-    if (!hasError) {
+QCString VhdlParser::unconstraint_array_definition() {QCString s,s1,s2,s3;if (!hasError) {
+    
     jj_consume_token(ARRAY_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     s = index_subtype_definition();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -8845,41 +10337,50 @@ QCString VhdlParser::unconstraint_array_definition() {QCString s,s1,s2,s3;
       default:
         jj_la1[230] = jj_gen;
         goto end_label_44;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = index_subtype_definition();
       }
       if (!hasError) {
+      
 s3+=",";s3+=s1;
       }
+      
     }
     end_label_44: ;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(OF_T);
     }
     if (!hasError) {
+    
     s2 = subtype_indication();
     }
+    
 return "array("+s+s3+") of "+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::use_clause() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::use_clause() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(USE_T);
     }
     if (!hasError) {
+    
     s = selected_name();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -8889,22 +10390,27 @@ QCString VhdlParser::use_clause() {QCString s,s1;
       default:
         jj_la1[231] = jj_gen;
         goto end_label_45;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       s1 = selected_name();
       }
       if (!hasError) {
+      
 s+=",";s+=s1;
       }
+      
     }
     end_label_45: ;
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCStringList ql1=QCStringList::split(",",s);
                    for (uint j=0;j<ql1.count();j++)
                    {
@@ -8918,7 +10424,7 @@ QCStringList ql1=QCStringList::split(",",s);
                    s1="use "+s;
                    return s1;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::variable_assignment_statement() {QCString s,s1,s2;
@@ -8927,46 +10433,57 @@ QCString VhdlParser::variable_assignment_statement() {QCString s,s1,s2;
     case SLSL_T:
     case STRINGLITERAL:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
-      if (jj_2_103(2)) {
-        if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
+      if (jj_2_104(2)) {if (!hasError) {
+        
         s = identifier();
         }
         if (!hasError) {
+        
         jj_consume_token(COLON_T);
         }
         if (!hasError) {
+        
 s+=":";
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
+      
       s1 = target();
       }
       if (!hasError) {
+      
       jj_consume_token(VARASSIGN_T);
       }
       if (!hasError) {
+      
       s2 = expression();
       }
       if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
       if (!hasError) {
+      
 return s+s1+":="+s2+";";
       }
+      
       break;
       }
-    case WITH_T:{
-      if (!hasError) {
+    case WITH_T:{if (!hasError) {
+      
       selected_variable_assignment();
       }
       if (!hasError) {
+      
 return "";
       }
+      
       break;
       }
     default:
@@ -8975,16 +10492,17 @@ return "";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s,s1,s2;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case SHARED_T:{
-      if (!hasError) {
+    case SHARED_T:{if (!hasError) {
+      
       tok = jj_consume_token(SHARED_T);
       }
+      
       break;
       }
     default:
@@ -8993,26 +10511,33 @@ QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s
     }
     }
     if (!hasError) {
+    
     jj_consume_token(VARIABLE_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s1 = subtype_indication();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case VARASSIGN_T:{
-      if (!hasError) {
+    case VARASSIGN_T:{if (!hasError) {
+      
       t1 = jj_consume_token(VARASSIGN_T);
       }
       if (!hasError) {
+      
       s2 = expression();
       }
+      
       break;
       }
     default:
@@ -9021,8 +10546,10 @@ QCString VhdlParser::variable_declaration() {Token *tok=0;Token *t1=0;QCString s
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 int spec;
     if(t1)
      s2.prepend(":=");
@@ -9044,20 +10571,22 @@ int spec;
     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
     return val;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
-    if (!hasError) {
+QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       s = identifier();
       }
       if (!hasError) {
+      
       t = jj_consume_token(COLON_T);
       }
+      
       break;
       }
     default:
@@ -9066,14 +10595,17 @@ QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(WAIT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ON_T:{
-      if (!hasError) {
+    case ON_T:{if (!hasError) {
+      
       s1 = sensitivity_clause();
       }
+      
       break;
       }
     default:
@@ -9082,11 +10614,13 @@ QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case UNTIL_T:{
-      if (!hasError) {
+    case UNTIL_T:{if (!hasError) {
+      
       s2 = condition_clause();
       }
+      
       break;
       }
     default:
@@ -9095,11 +10629,13 @@ QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case FOR_T:{
-      if (!hasError) {
+    case FOR_T:{if (!hasError) {
+      
       s3 = timeout_clause();
       }
+      
       break;
       }
     default:
@@ -9108,12 +10644,14 @@ QCString VhdlParser::wait_statement() {QCString s,s1,s2,s3;Token *t=0;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 if(t) s.append(":");
   return s+" wait "+s1+s2+s3+";";
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::waveform() {QCString s,s1;
@@ -9133,11 +10671,12 @@ QCString VhdlParser::waveform() {QCString s,s1;
     case CHARACTER_LITERAL:
     case DECIMAL_LITERAL:
     case BASED_LITERAL:
-    case BIT_STRING_LITERAL:{
-      if (!hasError) {
+    case BIT_STRING_LITERAL:{if (!hasError) {
+      
       s = waveform_element();
       }
       if (!hasError) {
+      
       while (!hasError) {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
         case COMMA_T:{
@@ -9147,31 +10686,38 @@ QCString VhdlParser::waveform() {QCString s,s1;
         default:
           jj_la1[239] = jj_gen;
           goto end_label_46;
-        }
-        if (!hasError) {
+        }if (!hasError) {
+        
         jj_consume_token(COMMA_T);
         }
         if (!hasError) {
+        
         s1 = waveform_element();
         }
         if (!hasError) {
+        
 s+=","; s+=s1;
         }
+        
       }
       end_label_46: ;
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case UNAFFECTED_T:{
-      if (!hasError) {
+    case UNAFFECTED_T:{if (!hasError) {
+      
       jj_consume_token(UNAFFECTED_T);
       }
       if (!hasError) {
+      
 return " unaffected ";
       }
+      
       break;
       }
     default:
@@ -9180,25 +10726,29 @@ return " unaffected ";
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::waveform_element() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::waveform_element() {QCString s,s1;if (!hasError) {
+    
     s = expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case AFTER_T:{
-      if (!hasError) {
+    case AFTER_T:{if (!hasError) {
+      
       jj_consume_token(AFTER_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
 s1.prepend(" after ");
       }
+      
       break;
       }
     default:
@@ -9206,37 +10756,45 @@ s1.prepend(" after ");
       ;
     }
     }
+    
 return s+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::protected_type_body() {
-    if (!hasError) {
+QCString VhdlParser::protected_type_body() {if (!hasError) {
+    
     jj_consume_token(PROTECTED_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BODY_T);
     }
     if (!hasError) {
+    
     protected_type_body_declarative_part();
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(PROTECTED_T);
     }
     if (!hasError) {
+    
     jj_consume_token(BODY_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -9244,9 +10802,10 @@ QCString VhdlParser::protected_type_body() {
       ;
     }
     }
+    
 return "";
 assert(false);
-}
+  }
 
 
 void VhdlParser::protected_type_body_declarative_item() {
@@ -9254,87 +10813,100 @@ void VhdlParser::protected_type_body_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       subprogram_body();
       }
+      
       break;
       }
-    case TYPE_T:{
-      if (!hasError) {
+    case TYPE_T:{if (!hasError) {
+      
       type_declaration();
       }
+      
       break;
       }
-    case SUBTYPE_T:{
-      if (!hasError) {
+    case SUBTYPE_T:{if (!hasError) {
+      
       subtype_declaration();
       }
+      
       break;
       }
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       constant_declaration();
       }
+      
       break;
       }
     case SHARED_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       variable_declaration();
       }
+      
       break;
       }
-    case FILE_T:{
-      if (!hasError) {
+    case FILE_T:{if (!hasError) {
+      
       file_declaration();
       }
+      
       break;
       }
-    case ALIAS_T:{
-      if (!hasError) {
+    case ALIAS_T:{if (!hasError) {
+      
       alias_declaration();
       }
+      
       break;
       }
     default:
       jj_la1[243] = jj_gen;
-      if (jj_2_104(2147483647)) {
-        if (!hasError) {
+      if (jj_2_105(2147483647)) {if (!hasError) {
+        
         attribute_declaration();
         }
+        
       } else {
         switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-        case ATTRIBUTE_T:{
-          if (!hasError) {
+        case ATTRIBUTE_T:{if (!hasError) {
+          
           attribute_specification();
           }
+          
           break;
           }
-        case USE_T:{
-          if (!hasError) {
+        case USE_T:{if (!hasError) {
+          
           use_clause();
           }
+          
           break;
           }
         default:
           jj_la1[244] = jj_gen;
-          if (jj_2_105(3)) {
-            if (!hasError) {
+          if (jj_2_106(3)) {if (!hasError) {
+            
             group_template_declaration();
             }
+            
           } else {
             switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-            case GROUP_T:{
-              if (!hasError) {
+            case GROUP_T:{if (!hasError) {
+              
               group_declaration();
               }
+              
               break;
               }
             default:
@@ -9346,11 +10918,11 @@ void VhdlParser::protected_type_body_declarative_item() {
         }
       }
     }
-}
+  }
 
 
-void VhdlParser::protected_type_body_declarative_part() {
-    if (!hasError) {
+void VhdlParser::protected_type_body_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ALIAS_T:
@@ -9374,42 +10946,50 @@ void VhdlParser::protected_type_body_declarative_part() {
       default:
         jj_la1[246] = jj_gen;
         goto end_label_47;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       protected_type_body_declarative_item();
       }
+      
     }
     end_label_47: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::protected_type_declaration() {
-    if (!hasError) {
+QCString VhdlParser::protected_type_declaration() {if (!hasError) {
+    
     jj_consume_token(PROTECTED_T);
     }
     if (!hasError) {
-    try {
-      if (!hasError) {
+    
+    try {if (!hasError) {
+      
       protected_type_declarative_part();
       }
+      
     } catch ( ...) {
 error_skipto(END_T);
     }
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(PROTECTED_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -9417,9 +10997,10 @@ error_skipto(END_T);
       ;
     }
     }
+    
 return "";
 assert(false);
-}
+  }
 
 
 void VhdlParser::protected_type_declarative_item() {
@@ -9427,22 +11008,25 @@ void VhdlParser::protected_type_declarative_item() {
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_specification();
       }
+      
       break;
       }
-    case ATTRIBUTE_T:{
-      if (!hasError) {
+    case ATTRIBUTE_T:{if (!hasError) {
+      
       attribute_specification();
       }
+      
       break;
       }
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       use_clause();
       }
+      
       break;
       }
     default:
@@ -9450,11 +11034,11 @@ void VhdlParser::protected_type_declarative_item() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::protected_type_declarative_part() {
-    if (!hasError) {
+void VhdlParser::protected_type_declarative_part() {if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ATTRIBUTE_T:
@@ -9469,48 +11053,58 @@ void VhdlParser::protected_type_declarative_part() {
       default:
         jj_la1[249] = jj_gen;
         goto end_label_48;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       protected_type_declarative_item();
       }
       if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
+      
     }
     end_label_48: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::context_ref() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::context_ref() {QCString s;if (!hasError) {
+    
     jj_consume_token(CONTEXT_T);
     }
     if (!hasError) {
+    
     s = identifier_list();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 return "context "+s ;
 assert(false);
-}
+  }
 
 
-void VhdlParser::context_declaration() {QCString s,s1;
-    if (!hasError) {
+void VhdlParser::context_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(CONTEXT_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
 parse_sec=CONTEXT_SEC;
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case CONTEXT_T:
@@ -9522,22 +11116,26 @@ parse_sec=CONTEXT_SEC;
       default:
         jj_la1[250] = jj_gen;
         goto end_label_49;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = libustcont_stats();
       }
+      
     }
     end_label_49: ;
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case CONTEXT_T:{
-      if (!hasError) {
+    case CONTEXT_T:{if (!hasError) {
+      
       jj_consume_token(CONTEXT_T);
       }
+      
       break;
       }
     default:
@@ -9546,12 +11144,14 @@ parse_sec=CONTEXT_SEC;
     }
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -9560,40 +11160,48 @@ parse_sec=CONTEXT_SEC;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 parse_sec=0;
                           addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
-}
+  }
 
 
 QCString VhdlParser::libustcont_stats() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case USE_T:{
-      if (!hasError) {
+    case USE_T:{if (!hasError) {
+      
       s = use_clause();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case LIBRARY_T:{
-      if (!hasError) {
+    case LIBRARY_T:{if (!hasError) {
+      
       s = library_clause();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case CONTEXT_T:{
-      if (!hasError) {
+    case CONTEXT_T:{if (!hasError) {
+      
       s = context_ref();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -9602,34 +11210,41 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;
-    if (!hasError) {
+void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(PACKAGE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     jj_consume_token(NEW_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
     s2 = signature();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       gen_assoc_list();
       }
+      
       break;
       }
     default:
@@ -9638,35 +11253,43 @@ void VhdlParser::package_instantiation_declaration() {QCString s,s1,s2;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCString q=" is new "+s1+s2;
       addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
-}
+  }
 
 
-QCString VhdlParser::interface_package_declaration() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::interface_package_declaration() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(PACKAGE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     jj_consume_token(NEW_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       gen_assoc_list();
       }
+      
       break;
       }
     default:
@@ -9674,37 +11297,45 @@ QCString VhdlParser::interface_package_declaration() {QCString s,s1;
       ;
     }
     }
+    
 current->name=s;
                             return "package "+s+" is new "+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(FUNCTION_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     jj_consume_token(IS_T);
     }
     if (!hasError) {
+    
     jj_consume_token(NEW_T);
     }
     if (!hasError) {
+    
     s1 = name();
     }
     if (!hasError) {
+    
     s2 = signature();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case GENERIC_T:{
-      if (!hasError) {
+    case GENERIC_T:{if (!hasError) {
+      
       gen_assoc_list();
       }
+      
       break;
       }
     default:
@@ -9713,122 +11344,152 @@ QCString VhdlParser::subprogram_instantiation_declaration() {QCString s,s1,s2;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
+    
 QCString q= " is new "+s1+s2;
       addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
     return q;
 assert(false);
-}
+  }
 
 
-void VhdlParser::gen_assoc_list() {
-    if (!hasError) {
+void VhdlParser::gen_assoc_list() {if (!hasError) {
+    
     jj_consume_token(GENERIC_T);
     }
     if (!hasError) {
+    
     jj_consume_token(MAP_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
     association_list();
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::gen_interface_list() {
-    if (!hasError) {
+void VhdlParser::gen_interface_list() {if (!hasError) {
+    
     jj_consume_token(GENERIC_T);
     }
     if (!hasError) {
+    
     jj_consume_token(LPAREN_T);
     }
     if (!hasError) {
+    
 //int u=s_str.iLine;
                           parse_sec=GEN_SEC;
     }
     if (!hasError) {
+    
     interface_list();
     }
     if (!hasError) {
+    
 //  QCString vo=$3;
                           parse_sec=0;
     }
     if (!hasError) {
+    
     jj_consume_token(RPAREN_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::case_scheme() {
-    if (!hasError) {
+void VhdlParser::case_scheme() {if (!hasError) {
+    
     jj_consume_token(CASE_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(GENERATE_T);
     }
     if (!hasError) {
+    
     when_stats();
     }
     if (!hasError) {
-    if (jj_2_106(3)) {
-      if (!hasError) {
+    
+    if (jj_2_107(3)) {if (!hasError) {
+      
       ttend();
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     jj_consume_token(GENERATE_T);
     }
     if (!hasError) {
+    
     generate_statement_body();
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::when_stats() {
-    if (!hasError) {
-    while (!hasError) {
-      if (!hasError) {
+void VhdlParser::when_stats() {if (!hasError) {
+    
+    while (!hasError) {if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
-      if (jj_2_107(2)) {
-        if (!hasError) {
+      
+      if (jj_2_108(2)) {if (!hasError) {
+        
         label();
         }
         if (!hasError) {
+        
         jj_consume_token(COLON_T);
         }
+        
       } else {
         ;
       }
       }
       if (!hasError) {
+      
       choices();
       }
       if (!hasError) {
+      
       jj_consume_token(ARROW_T);
       }
       if (!hasError) {
+      
       generate_statement_body();
       }
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case WHEN_T:{
         ;
@@ -9841,20 +11502,23 @@ void VhdlParser::when_stats() {
     }
     end_label_50: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::ttend() {
-    if (!hasError) {
+void VhdlParser::ttend() {if (!hasError) {
+    
     jj_consume_token(END_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       identifier();
       }
+      
       break;
       }
     default:
@@ -9863,23 +11527,27 @@ void VhdlParser::ttend() {
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::generate_statement_body() {
-    if (!hasError) {
+void VhdlParser::generate_statement_body() {if (!hasError) {
+    
     jj_consume_token(BEGIN_T);
     }
     if (!hasError) {
+    
     generate_statement_body();
     }
-}
+    
+  }
 
 
-void VhdlParser::generate_statement_body1() {
-    if (!hasError) {
+void VhdlParser::generate_statement_body1() {if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case ALIAS_T:
     case ATTRIBUTE_T:
@@ -9899,23 +11567,26 @@ void VhdlParser::generate_statement_body1() {
     case SUBTYPE_T:
     case TYPE_T:
     case USE_T:
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       while (!hasError) {
-        if (jj_2_108(2147483647)) {
+        if (jj_2_109(2147483647)) {
           ;
         } else {
           goto end_label_51;
-        }
-        if (!hasError) {
+        }if (!hasError) {
+        
         block_declarative_item();
         }
+        
       }
       end_label_51: ;
       }
       if (!hasError) {
+      
       jj_consume_token(BEGIN_T);
       }
+      
       break;
       }
     default:
@@ -9924,6 +11595,7 @@ void VhdlParser::generate_statement_body1() {
     }
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ASSERT_T:
@@ -9943,69 +11615,83 @@ void VhdlParser::generate_statement_body1() {
       default:
         jj_la1[260] = jj_gen;
         goto end_label_52;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       concurrent_statement();
       }
+      
     }
     end_label_52: ;
     }
-}
+    
+  }
 
 
-QCString VhdlParser::external_name() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::external_name() {QCString s,s1,s2;if (!hasError) {
+    
     jj_consume_token(SLSL_T);
     }
     if (!hasError) {
+    
     s = sig_stat();
     }
     if (!hasError) {
+    
     s1 = external_pathname();
     }
     if (!hasError) {
+    
     jj_consume_token(COLON_T);
     }
     if (!hasError) {
+    
     s2 = subtype_indication();
     }
     if (!hasError) {
+    
     jj_consume_token(RSRS_T);
     }
+    
 QCString t="<<"+s;
                          QCString t1=s1+":"+s2+">>";
                          return   s+s1;
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::sig_stat() {Token *t;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case CONSTANT_T:{
-      if (!hasError) {
+    case CONSTANT_T:{if (!hasError) {
+      
       t = jj_consume_token(CONSTANT_T);
       }
       if (!hasError) {
+      
 return t->image.data();
       }
+      
       break;
       }
-    case SIGNAL_T:{
-      if (!hasError) {
+    case SIGNAL_T:{if (!hasError) {
+      
       t = jj_consume_token(SIGNAL_T);
       }
       if (!hasError) {
+      
 return t->image.data();
       }
+      
       break;
       }
-    case VARIABLE_T:{
-      if (!hasError) {
+    case VARIABLE_T:{if (!hasError) {
+      
       t = jj_consume_token(VARIABLE_T);
       }
       if (!hasError) {
+      
 return t->image.data();
       }
+      
       break;
       }
     default:
@@ -10014,36 +11700,42 @@ return t->image.data();
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::external_pathname() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case DOT_T:{
-      if (!hasError) {
+    case DOT_T:{if (!hasError) {
+      
       s = absolute_pathname();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case NEG_T:{
-      if (!hasError) {
+    case NEG_T:{if (!hasError) {
+      
       s = relative_pathname();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
-    case AT_T:{
-      if (!hasError) {
+    case AT_T:{if (!hasError) {
+      
       s = package_path_name();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -10052,35 +11744,42 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
 QCString VhdlParser::absolute_pathname() {QCString s,s1;
-    if (jj_2_109(2147483647)) {
-      if (!hasError) {
+    if (jj_2_110(2147483647)) {if (!hasError) {
+      
       jj_consume_token(DOT_T);
       }
       if (!hasError) {
+      
       s = pathname_element_list();
       }
       if (!hasError) {
+      
       s1 = identifier();
       }
       if (!hasError) {
+      
 return "."+s+s1;
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case DOT_T:{
-        if (!hasError) {
+      case DOT_T:{if (!hasError) {
+        
         jj_consume_token(DOT_T);
         }
         if (!hasError) {
+        
         s = identifier();
         }
         if (!hasError) {
+        
 return "."+s;
         }
+        
         break;
         }
       default:
@@ -10090,42 +11789,49 @@ return "."+s;
       }
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::relative_pathname() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::relative_pathname() {QCString s,s1,s2;if (!hasError) {
+    
     s = neg_list();
     }
     if (!hasError) {
-    if (jj_2_110(2147483647)) {
-      if (!hasError) {
+    
+    if (jj_2_111(2147483647)) {if (!hasError) {
+      
       s1 = pathname_element_list();
       }
+      
     } else {
       ;
     }
     }
     if (!hasError) {
+    
     s2 = identifier();
     }
+    
 return s+s1+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::neg_list() {QCString s;
-    if (!hasError) {
-    while (!hasError) {
-      if (!hasError) {
+QCString VhdlParser::neg_list() {QCString s;if (!hasError) {
+    
+    while (!hasError) {if (!hasError) {
+      
       jj_consume_token(NEG_T);
       }
       if (!hasError) {
+      
       jj_consume_token(DOT_T);
       }
       if (!hasError) {
+      
 s+="^.";
       }
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case NEG_T:{
         ;
@@ -10138,27 +11844,32 @@ s+="^.";
     }
     end_label_53: ;
     }
+    
 return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::pathname_element() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::pathname_element() {QCString s,s1;if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = expression();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
+      
       break;
       }
     default:
@@ -10166,77 +11877,90 @@ QCString VhdlParser::pathname_element() {QCString s,s1;
       ;
     }
     }
+    
 if(!s1.isEmpty())
      return s+"("+s1+")";
 
     return s;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::pathname_element_list() {QCString s,s1,s2;
-    if (!hasError) {
+QCString VhdlParser::pathname_element_list() {QCString s,s1,s2;if (!hasError) {
     if (!hasError) {
+    
     s = pathname_element();
     }
     if (!hasError) {
+    
     jj_consume_token(DOT_T);
     }
+    
     }
     if (!hasError) {
+    
 s+=".";
     }
     if (!hasError) {
+    
     while (!hasError) {
-      if (jj_2_111(2147483647)) {
+      if (jj_2_112(2147483647)) {
         ;
       } else {
         goto end_label_54;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       s1 = pathname_element();
       }
       if (!hasError) {
+      
       jj_consume_token(DOT_T);
       }
       if (!hasError) {
+      
 s2+=s1;s2+=".";
       }
+      
     }
     end_label_54: ;
     }
+    
 return s+s2;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::package_path_name() {QCString s;
-    if (!hasError) {
+QCString VhdlParser::package_path_name() {QCString s;if (!hasError) {
+    
     jj_consume_token(AT_T);
     }
     if (!hasError) {
+    
     s = name();
     }
+    
 return "@"+s;
 assert(false);
-}
+  }
 
 
 void VhdlParser::conditional_signal_assignment_wave() {
-    if (jj_2_112(2147483647)) {
-      if (!hasError) {
+    if (jj_2_113(2147483647)) {if (!hasError) {
+      
       conditional_force_assignment();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case LPAREN_T:
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         conditional_waveform_assignment();
         }
+        
         break;
         }
       default:
@@ -10245,24 +11969,27 @@ void VhdlParser::conditional_signal_assignment_wave() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::conditional_waveform_assignment() {
-    if (!hasError) {
+void VhdlParser::conditional_waveform_assignment() {if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case INERTIAL_T:
     case REJECT_T:
-    case TRANSPORT_T:{
-      if (!hasError) {
+    case TRANSPORT_T:{if (!hasError) {
+      
       delay_mechanism();
       }
+      
       break;
       }
     default:
@@ -10271,20 +11998,25 @@ void VhdlParser::conditional_waveform_assignment() {
     }
     }
     if (!hasError) {
+    
     waveform_element();
     }
     if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case ELSE_T:{
-      if (!hasError) {
+    case ELSE_T:{if (!hasError) {
+      
       else_wave_list();
       }
+      
       break;
       }
     default:
@@ -10293,27 +12025,33 @@ void VhdlParser::conditional_waveform_assignment() {
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
-void VhdlParser::else_wave_list() {
-    if (!hasError) {
+void VhdlParser::else_wave_list() {if (!hasError) {
+    
     jj_consume_token(ELSE_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case WHEN_T:{
-      if (!hasError) {
+    case WHEN_T:{if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       expression();
       }
+      
       break;
       }
     default:
@@ -10321,26 +12059,31 @@ void VhdlParser::else_wave_list() {
       ;
     }
     }
-}
+    
+  }
 
 
-void VhdlParser::conditional_force_assignment() {
-    if (!hasError) {
+void VhdlParser::conditional_force_assignment() {if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(FORCE_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case IN_T:
-    case OUT_T:{
-      if (!hasError) {
+    case OUT_T:{if (!hasError) {
+      
       inout_stat();
       }
+      
       break;
       }
     default:
@@ -10349,12 +12092,15 @@ void VhdlParser::conditional_force_assignment() {
     }
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case ABS_T:
     case NEW_T:
@@ -10371,13 +12117,15 @@ void VhdlParser::conditional_force_assignment() {
     case CHARACTER_LITERAL:
     case DECIMAL_LITERAL:
     case BASED_LITERAL:
-    case BIT_STRING_LITERAL:{
-      if (!hasError) {
+    case BIT_STRING_LITERAL:{if (!hasError) {
+      
       expression();
       }
       if (!hasError) {
+      
       else_stat();
       }
+      
       break;
       }
     default:
@@ -10386,22 +12134,26 @@ void VhdlParser::conditional_force_assignment() {
     }
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
 void VhdlParser::selected_signal_assignment_wave() {
-    if (jj_2_113(2147483647)) {
-      if (!hasError) {
+    if (jj_2_114(2147483647)) {if (!hasError) {
+      
       selected_force_assignment();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case WITH_T:{
-        if (!hasError) {
+      case WITH_T:{if (!hasError) {
+        
         selected_waveform_assignment();
         }
+        
         break;
         }
       default:
@@ -10410,25 +12162,29 @@ void VhdlParser::selected_signal_assignment_wave() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::selected_variable_assignment() {
-    if (!hasError) {
+void VhdlParser::selected_variable_assignment() {if (!hasError) {
+    
     jj_consume_token(WITH_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SELECT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case Q_T:{
-      if (!hasError) {
+    case Q_T:{if (!hasError) {
+      
       jj_consume_token(Q_T);
       }
+      
       break;
       }
     default:
@@ -10437,31 +12193,37 @@ void VhdlParser::selected_variable_assignment() {
     }
     }
     if (!hasError) {
+    
     select_name();
     }
     if (!hasError) {
+    
     jj_consume_token(VARASSIGN_T);
     }
     if (!hasError) {
+    
     sel_var_list();
     }
-}
+    
+  }
 
 
 void VhdlParser::select_name() {
-    if (jj_2_114(2147483647)) {
-      if (!hasError) {
+    if (jj_2_115(2147483647)) {if (!hasError) {
+      
       aggregate();
       }
+      
     } else {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case SLSL_T:
       case STRINGLITERAL:
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         name();
         }
+        
         break;
         }
       default:
@@ -10470,25 +12232,29 @@ void VhdlParser::select_name() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
     }
-}
+  }
 
 
-void VhdlParser::selected_waveform_assignment() {
-    if (!hasError) {
+void VhdlParser::selected_waveform_assignment() {if (!hasError) {
+    
     jj_consume_token(WITH_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SELECT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case Q_T:{
-      if (!hasError) {
+    case Q_T:{if (!hasError) {
+      
       jj_consume_token(Q_T);
       }
+      
       break;
       }
     default:
@@ -10497,19 +12263,23 @@ void VhdlParser::selected_waveform_assignment() {
     }
     }
     if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case INERTIAL_T:
     case REJECT_T:
-    case TRANSPORT_T:{
-      if (!hasError) {
+    case TRANSPORT_T:{if (!hasError) {
+      
       delay_mechanism();
       }
+      
       break;
       }
     default:
@@ -10518,27 +12288,33 @@ void VhdlParser::selected_waveform_assignment() {
     }
     }
     if (!hasError) {
+    
     sel_wave_list();
     }
-}
+    
+  }
 
 
-void VhdlParser::selected_force_assignment() {
-    if (!hasError) {
+void VhdlParser::selected_force_assignment() {if (!hasError) {
+    
     jj_consume_token(WITH_T);
     }
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(SELECT_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case Q_T:{
-      if (!hasError) {
+    case Q_T:{if (!hasError) {
+      
       jj_consume_token(Q_T);
       }
+      
       break;
       }
     default:
@@ -10547,21 +12323,26 @@ void VhdlParser::selected_force_assignment() {
     }
     }
     if (!hasError) {
+    
     target();
     }
     if (!hasError) {
+    
     jj_consume_token(LESSTHAN_T);
     }
     if (!hasError) {
+    
     jj_consume_token(FORCE_T);
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case IN_T:
-    case OUT_T:{
-      if (!hasError) {
+    case OUT_T:{if (!hasError) {
+      
       inout_stat();
       }
+      
       break;
       }
     default:
@@ -10570,34 +12351,41 @@ void VhdlParser::selected_force_assignment() {
     }
     }
     if (!hasError) {
+    
     sel_var_list();
     }
-}
+    
+  }
 
 
-void VhdlParser::sel_var_list() {
-    if (!hasError) {
+void VhdlParser::sel_var_list() {if (!hasError) {
     if (!hasError) {
+    
     expression();
     }
     if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     choices();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case COMMA_T:{
-      if (!hasError) {
+    case COMMA_T:{if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
+      
       break;
       }
-    case SEMI_T:{
-      if (!hasError) {
+    case SEMI_T:{if (!hasError) {
+      
       jj_consume_token(SEMI_T);
       }
+      
       break;
       }
     default:
@@ -10606,35 +12394,42 @@ void VhdlParser::sel_var_list() {
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
     }
+    
     }
     if (!hasError) {
+    
     while (!hasError) {
-      if (jj_2_115(2147483647)) {
+      if (jj_2_116(2147483647)) {
         ;
       } else {
         goto end_label_55;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       expression();
       }
       if (!hasError) {
+      
       jj_consume_token(WHEN_T);
       }
       if (!hasError) {
+      
       choices();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case COMMA_T:{
-        if (!hasError) {
+      case COMMA_T:{if (!hasError) {
+        
         jj_consume_token(COMMA_T);
         }
+        
         break;
         }
-      case SEMI_T:{
-        if (!hasError) {
+      case SEMI_T:{if (!hasError) {
+        
         jj_consume_token(SEMI_T);
         }
+        
         break;
         }
       default:
@@ -10643,23 +12438,28 @@ void VhdlParser::sel_var_list() {
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
       }
+      
     }
     end_label_55: ;
     }
-}
+    
+  }
 
 
-void VhdlParser::sel_wave_list() {
-    if (!hasError) {
+void VhdlParser::sel_wave_list() {if (!hasError) {
+    
     waveform_element();
     }
     if (!hasError) {
+    
     jj_consume_token(WHEN_T);
     }
     if (!hasError) {
+    
     choices();
     }
     if (!hasError) {
+    
     while (!hasError) {
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case COMMA_T:{
@@ -10669,34 +12469,40 @@ void VhdlParser::sel_wave_list() {
       default:
         jj_la1[281] = jj_gen;
         goto end_label_56;
-      }
-      if (!hasError) {
+      }if (!hasError) {
+      
       jj_consume_token(COMMA_T);
       }
       if (!hasError) {
+      
       sel_wave_list();
       }
+      
     }
     end_label_56: ;
     }
     if (!hasError) {
+    
     jj_consume_token(SEMI_T);
     }
-}
+    
+  }
 
 
 void VhdlParser::inout_stat() {
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IN_T:{
-      if (!hasError) {
+    case IN_T:{if (!hasError) {
+      
       jj_consume_token(IN_T);
       }
+      
       break;
       }
-    case OUT_T:{
-      if (!hasError) {
+    case OUT_T:{if (!hasError) {
+      
       jj_consume_token(OUT_T);
       }
+      
       break;
       }
     default:
@@ -10704,27 +12510,31 @@ void VhdlParser::inout_stat() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-void VhdlParser::else_stat() {
-    if (!hasError) {
-    while (!hasError) {
-      if (!hasError) {
+void VhdlParser::else_stat() {if (!hasError) {
+    
+    while (!hasError) {if (!hasError) {
+      
       jj_consume_token(ELSE_T);
       }
       if (!hasError) {
+      
       expression();
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case WHEN_T:{
-        if (!hasError) {
+      case WHEN_T:{if (!hasError) {
+        
         jj_consume_token(WHEN_T);
         }
         if (!hasError) {
+        
         expression();
         }
+        
         break;
         }
       default:
@@ -10732,6 +12542,7 @@ void VhdlParser::else_stat() {
         ;
       }
       }
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case ELSE_T:{
         ;
@@ -10744,29 +12555,34 @@ void VhdlParser::else_stat() {
     }
     end_label_57: ;
     }
-}
+    
+  }
 
 
 QCString VhdlParser::interface_subprogram_declaration() {QCString s;
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PROCEDURE_T:{
-      if (!hasError) {
+    case PROCEDURE_T:{if (!hasError) {
+      
       s = iproc();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     case FUNCTION_T:
     case IMPURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       s = ifunc();
       }
       if (!hasError) {
+      
 return s;
       }
+      
       break;
       }
     default:
@@ -10775,41 +12591,46 @@ return s;
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::iproc() {QCString s,s1;
-    if (!hasError) {
+QCString VhdlParser::iproc() {QCString s,s1;if (!hasError) {
+    
     jj_consume_token(PROCEDURE_T);
     }
     if (!hasError) {
+    
     s = identifier();
     }
     if (!hasError) {
+    
     s1 = param();
     }
+    
 current->name=s;
   return "procedure "+s+s1;
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;
-    if (!hasError) {
+QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
     case IMPURE_T:
     case PURE_T:{
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-      case PURE_T:{
-        if (!hasError) {
+      case PURE_T:{if (!hasError) {
+        
         t = jj_consume_token(PURE_T);
         }
+        
         break;
         }
-      case IMPURE_T:{
-        if (!hasError) {
+      case IMPURE_T:{if (!hasError) {
+        
         t = jj_consume_token(IMPURE_T);
         }
+        
         break;
         }
       default:
@@ -10825,39 +12646,48 @@ QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *
     }
     }
     if (!hasError) {
+    
     jj_consume_token(FUNCTION_T);
     }
     if (!hasError) {
+    
     s = name();
     }
     if (!hasError) {
+    
     s1 = param();
     }
     if (!hasError) {
+    
     jj_consume_token(RETURN_T);
     }
     if (!hasError) {
+    
     s2 = name();
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case IS_T:{
-      if (!hasError) {
+    case IS_T:{if (!hasError) {
+      
       t1 = jj_consume_token(IS_T);
       }
       if (!hasError) {
+      
       switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
       case BASIC_IDENTIFIER:
-      case EXTENDED_CHARACTER:{
-        if (!hasError) {
+      case EXTENDED_CHARACTER:{if (!hasError) {
+        
         s3 = identifier();
         }
+        
         break;
         }
-      case BOX_T:{
-        if (!hasError) {
+      case BOX_T:{if (!hasError) {
+        
         t2 = jj_consume_token(BOX_T);
         }
+        
         break;
         }
       default:
@@ -10866,6 +12696,7 @@ QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *
         errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
       }
       }
+      
       break;
       }
     default:
@@ -10873,6 +12704,7 @@ QCString VhdlParser::ifunc() {QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *
       ;
     }
     }
+    
 QCString q;
       if(t) q=t->image.data();
       if(t2) s3="<>";
@@ -10892,16 +12724,17 @@ QCString q;
                     }
          currP=0;return "";
 assert(false);
-}
+  }
 
 
-QCString VhdlParser::param() {QCString s,s1;Token *tok=0;
-    if (!hasError) {
+QCString VhdlParser::param() {QCString s,s1;Token *tok=0;if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case PARAMETER_T:{
-      if (!hasError) {
+    case PARAMETER_T:{if (!hasError) {
+      
       tok = jj_consume_token(PARAMETER_T);
       }
+      
       break;
       }
     default:
@@ -10910,20 +12743,25 @@ QCString VhdlParser::param() {QCString s,s1;Token *tok=0;
     }
     }
     if (!hasError) {
+    
 param_sec=PARAM_SEC;
     }
     if (!hasError) {
+    
     switch ((jj_ntk==-1)?jj_ntk_f():jj_ntk) {
-    case LPAREN_T:{
-      if (!hasError) {
+    case LPAREN_T:{if (!hasError) {
+      
       jj_consume_token(LPAREN_T);
       }
       if (!hasError) {
+      
       s1 = interface_list();
       }
       if (!hasError) {
+      
       jj_consume_token(RPAREN_T);
       }
+      
       break;
       }
     default:
@@ -10931,6 +12769,7 @@ param_sec=PARAM_SEC;
       ;
     }
     }
+    
 if(tok)
                      {
                       s = tok->image.data();
@@ -10939,7 +12778,7 @@ if(tok)
                       param_sec=0;
                       return s+"("+s1+")";
 assert(false);
-}
+  }
 
 
 void VhdlParser::parseInline() {
@@ -10947,19 +12786,21 @@ void VhdlParser::parseInline() {
     case POSTPONED_T:
     case PROCESS_T:
     case BASIC_IDENTIFIER:
-    case EXTENDED_CHARACTER:{
-      if (!hasError) {
+    case EXTENDED_CHARACTER:{if (!hasError) {
+      
       process_statement();
       }
+      
       break;
       }
     case FUNCTION_T:
     case IMPURE_T:
     case PROCEDURE_T:
-    case PURE_T:{
-      if (!hasError) {
+    case PURE_T:{if (!hasError) {
+      
       subprogram_declaration();
       }
+      
       break;
       }
     default:
@@ -10967,71 +12808,65 @@ void VhdlParser::parseInline() {
       jj_consume_token(-1);
       errorHandler->handleParseError(token, getToken(1), __FUNCTION__, this), hasError = true;
     }
-}
+  }
 
 
-  VhdlParser::VhdlParser(TokenManager *tokenManager){
-    head = nullptr;
-    ReInit(tokenManager);
+ VhdlParser::VhdlParser(TokenManager *tm){
+    head = NULL;
+    ReInit(tm);
 }
-VhdlParser::~VhdlParser()
+   VhdlParser::~VhdlParser()
 {
-  clear();
+  if (token_source) delete token_source;
+  if (head) {
+    Token *next, *t = head;
+    while (t) {
+      next = t->next;
+      delete t;
+      t = next;
+    }
+  }
+  if (errorHandlerCreated) {
+    delete errorHandler;
+  }
 }
 
-void VhdlParser::ReInit(TokenManager* tokenManager){
-    clear();
+void VhdlParser::ReInit(TokenManager *tm){
+    if (head) delete head;
     errorHandler = new ErrorHandler();
+    errorHandlerCreated = true;
     hasError = false;
-    token_source = tokenManager;
+    token_source = tm;
     head = token = new Token();
     token->kind = 0;
-    token->next = nullptr;
+    token->next = NULL;
     jj_lookingAhead = false;
     jj_rescan = false;
     jj_done = false;
-    jj_scanpos = jj_lastpos = nullptr;
+    jj_scanpos = jj_lastpos = NULL;
     jj_gc = 0;
     jj_kind = -1;
-    indent = 0;
-    trace = false;
+    trace_indent = 0;
+    trace_enabled = false;
     jj_ntk = -1;
     jj_gen = 0;
     for (int i = 0; i < 293; i++) jj_la1[i] = -1;
   }
 
 
-void VhdlParser::clear(){
-  //Since token manager was generate from outside,
-  //parser should not take care of deleting
-  //if (token_source) delete token_source;
-  if (head) {
-    Token *next, *t = head;
-    while (t) {
-      next = t->next;
-      delete t;
-      t = next;
-    }
-  }
-  if (errorHandler) {
-    delete errorHandler, errorHandler = nullptr;
-  }
-}
-
-
 Token * VhdlParser::jj_consume_token(int kind)  {
     Token *oldToken;
-    if ((oldToken = token)->next != nullptr) token = token->next;
+    if ((oldToken = token)->next != NULL) token = token->next;
     else token = token->next = token_source->getNextToken();
     jj_ntk = -1;
     if (token->kind == kind) {
       jj_gen++;
       if (++jj_gc > 100) {
         jj_gc = 0;
-        for (int i = 0; i < 115; i++) {
+        for (int i = 0; i < 116; i++) {
           JJCalls *c = &jj_2_rtns[i];
-          while (c != nullptr) {
-            if (c->gen < jj_gen) c->first = nullptr;
+          while (c != NULL) {
+            if (c->gen < jj_gen) c->first = NULL;
             c = c->next;
           }
         }
@@ -11040,9 +12875,8 @@ Token * VhdlParser::jj_consume_token(int kind)  {
     }
     token = oldToken;
     jj_kind = kind;
-    JJString image = kind >= 0 ? tokenImage[kind] : tokenImage[0];
-    errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this);
-    hasError = true;
+    JAVACC_STRING_TYPE image = kind >= 0 ? tokenImage[kind] : tokenImage[0];
+    errorHandler->handleUnexpectedToken(kind, image.substr(1, image.size() - 2), getToken(1), this), hasError = true;
     return token;
   }
 
@@ -11050,7 +12884,7 @@ Token * VhdlParser::jj_consume_token(int kind)  {
 bool  VhdlParser::jj_scan_token(int kind){
     if (jj_scanpos == jj_lastpos) {
       jj_la--;
-      if (jj_scanpos->next == nullptr) {
+      if (jj_scanpos->next == NULL) {
         jj_lastpos = jj_scanpos = jj_scanpos->next = token_source->getNextToken();
       } else {
         jj_lastpos = jj_scanpos = jj_scanpos->next;
@@ -11060,8 +12894,8 @@ bool  VhdlParser::jj_scan_token(int kind){
     }
     if (jj_rescan) {
       int i = 0; Token *tok = token;
-      while (tok != nullptr && tok != jj_scanpos) { i++; tok = tok->next; }
-      if (tok != nullptr) jj_add_error_token(kind, i);
+      while (tok != NULL && tok != jj_scanpos) { i++; tok = tok->next; }
+      if (tok != NULL) jj_add_error_token(kind, i);
     }
     if (jj_scanpos->kind != kind) return true;
     if (jj_la == 0 && jj_scanpos == jj_lastpos) { return jj_done = true; }
@@ -11072,7 +12906,7 @@ bool  VhdlParser::jj_scan_token(int kind){
 /** Get the next Token. */
 
 Token * VhdlParser::getNextToken(){
-    if (token->next != nullptr) token = token->next;
+    if (token->next != NULL) token = token->next;
     else token = token->next = token_source->getNextToken();
     jj_ntk = -1;
     jj_gen++;
@@ -11084,7 +12918,7 @@ Token * VhdlParser::getNextToken(){
 Token * VhdlParser::getToken(int index){
     Token *t = token;
     for (int i = 0; i < index; i++) {
-      if (t->next != nullptr) t = t->next;
+      if (t->next != NULL) t = t->next;
       else t = t->next = token_source->getNextToken();
     }
     return t;
@@ -11092,37 +12926,35 @@ Token * VhdlParser::getToken(int index){
 
 
 int VhdlParser::jj_ntk_f(){
-    if ((jj_nt=token->next) == nullptr)
+    if ((jj_nt=token->next) == NULL)
       return (jj_ntk = (token->next=token_source->getNextToken())->kind);
     else
       return (jj_ntk = jj_nt->kind);
   }
 
 
-  void VhdlParser::jj_add_error_token(int kind, int pos)  {
+void VhdlParser::jj_add_error_token(int kind, int pos)  {
   }
 
+  /** Generate ParseException. */
 
  void  VhdlParser::parseError()   {
       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());
    }
 
 
-  bool VhdlParser::trace_enabled()  {
-    return trace;
+ void VhdlParser::enable_tracing()  {
   }
 
+  /** Disable tracing. */
 
-  void VhdlParser::enable_tracing()  {
-  }
-
-  void VhdlParser::disable_tracing()  {
+ void VhdlParser::disable_tracing()  {
   }
 
 
-  void VhdlParser::jj_rescan_token(){
+void VhdlParser::jj_rescan_token(){
     jj_rescan = true;
-    for (int i = 0; i < 115; i++) {
+    for (int i = 0; i < 116; i++) {
       JJCalls *p = &jj_2_rtns[i];
       do {
         if (p->gen > jj_gen) {
@@ -11243,19 +13075,20 @@ int VhdlParser::jj_ntk_f(){
             case 112: jj_3_113(); break;
             case 113: jj_3_114(); break;
             case 114: jj_3_115(); break;
+            case 115: jj_3_116(); break;
           }
         }
         p = p->next;
-      } while (p != nullptr);
+      } while (p != NULL);
     }
     jj_rescan = false;
   }
 
 
-  void VhdlParser::jj_save(int index, int xla){
+void VhdlParser::jj_save(int index, int xla){
     JJCalls *p = &jj_2_rtns[index];
     while (p->gen > jj_gen) {
-      if (p->next == nullptr) { p = p->next = new JJCalls(); break; }
+      if (p->next == NULL) { p = p->next = new JJCalls(); break; }
       p = p->next;
     }
     p->gen = jj_gen + xla - jj_la; p->first = token; p->arg = xla;