vhdlparser/vhdlparser.jj

   1 /******************************************************************************
   2  *
   3  * Copyright (C) 2014 by M. Kreis
   4  *
   5  * Permission to use, copy, modify, and distribute this software and its
   6  * documentation under the terms of the GNU General Public License is hereby
   7  * granted. No representations are made about the suitability of this software
   8  * for any purpose. It is provided "as is" without express or implied warranty.
   9  * See the GNU General Public License for more details.
  10  *
  11  */
  12 options {
  13   JAVA_UNICODE_ESCAPE = true;
  14   OUTPUT_LANGUAGE = "c++";
  15   NAMESPACE = "vhdl::parser";
  16   STATIC=false;
  17   PARSER_INCLUDES="vhdljjparser.h";
  18   TOKEN_MANAGER_INCLUDES="VhdlParser.h";
  19
  20  //OUTPUT_DIRECTORY = ".";
  21  //DEBUG_PARSER=true;
  22  //DEBUG_LOOKAHEAD=true;
  23
  24   }
  25
  26 PARSER_BEGIN(VhdlParser)
  27
  28 typedef unsigned long long uint64;
  29
  30 static Entry* current_root;
  31 static Entry* tempEntry;
  32 static Entry*  lastEntity  ;
  33 static Entry*  lastCompound  ;
  34 static Entry*  current;
  35 static QCString compSpec;
  36 static QCString currName;
  37 static int levelCounter;
  38 static QCString confName;
  39 static QCString genLabels;
  40 static QCString lab;
  41 static QCString forL;
  42 static int param_sec ;
  43 static int parse_sec;
  44 static int currP;
  45 static Entry* currentCompound;
  46
  47 //----------------------------------------
  48
  49 static void setLineParsed(int tok);
  50 static int getLine(int tok);
  51 static int getLine();
  52 static void lineCount(const char*);
  53 static void lineCount();
  54 static void addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6);
  55 static void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf);
  56 static void createFunction(const char *impure,uint64 spec,const char *fname);
  57 static void addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot);
  58 static void addCompInst(const char *n, const char* instName, const char* comp,int iLine);
  59 static void handleCommentBlock(const char* doc,bool brief);
  60 static void handleFlowComment(const char*);
  61 static void initEntry(Entry *e);
  62 static  void newEntry();
  63 static  bool isFuncProcProced();
  64 static void pushLabel(QCString &,QCString&);
  65 static  QCString popLabel(QCString & q);
  66 static  bool addLibUseClause(const QCString &type);
  67 static  void mapLibPackage( Entry* root);
  68 static void createFlow();
  69 static void error_skipto(int kind);
  70 static void oneLineComment(QCString qcs);
  71 static void setMultCommentLine();
  72 PARSER_END(VhdlParser)
  73
  74 SKIP :
  75 {
  76   " "
  77 | "\t"
  78 | "\n" {::vhdl::parser::VhdlParser::lineCount();}
  79 | "\r"
  80 }
  81
  82 SKIP:
  83 {
  84   // VHDL comment -- ......
  85   // VHDL doxygen line comment --! ....
  86   <#DOXYGEN_VHDL_COMMENT: (" "|"\t")*"--!"(~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>
  87   | <MULT_DOXYGEN_COMMENT: (<DOXYGEN_VHDL_COMMENT>)+ >
  88   {
  89     {
  90     QCString doc(image.data());
  91     int count=doc.contains("--!");
  92     ::vhdl::parser::VhdlParser::setMultCommentLine();
  93     ::vhdl::parser::VhdlParser::lineCount(image.data());
  94     if (count == 1)
  95       ::vhdl::parser::VhdlParser::oneLineComment(doc);
  96     else
  97       ::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),FALSE); ;
  98     }
  99
 100   }
 101   |<VHDL_FLOWCHART_COMMENT: "--#" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>  { ::vhdl::parser::VhdlParser::handleFlowComment(image.data());}
 102   |<VHDL_COMMENT: "--" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>
 103   {
 104     ::vhdl::parser::VhdlParser::lineCount(image.data());}
 105   }
 106
 107 // VHDL 2008  comment /* .... */
 108 // VHDL 2008 doxygen comment /*! .... */
 109 SKIP :
 110 {
 111   <MULT_DOXYGEN_VHDL_COMMENT_2008 : "/*!"  (~[])* "*/" >
 112   {
 113    {
 114      QCString q(image.data());
 115      q.stripPrefix("/*!");
 116      q.resize(q.length()-2);
 117      ::vhdl::parser::VhdlParser::handleCommentBlock(q.data(),TRUE);image.clear();
 118    }
 119   }
 120   | <MULT_VHDL_2008_COMMENT : "/*"  (~[])* "*/" >  {::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();}
 121 }
 122
 123 /* KEYWORDS */
 124
 125 TOKEN [IGNORE_CASE] :
 126 {
 127  <ABS_T: "abs">
 128 | <ACCESS_T: "access">
 129 | <AFTER_T: "after">
 130 | <ALIAS_T: "alias">
 131 | <ALL_T: "all">
 132 | <AND_T: "and">
 133 | <ARCHITECTURE_T: "architecture"> {::vhdl::parser::VhdlParser::setLineParsed(ARCHITECTURE_T);}
 134 | <ARRAY_T: "array"> {VhdlParser::setLineParsed(ARRAY_T);}
 135 | <ASSERT_T: "assert">
 136 | <ASSUME_T: "assume">
 137 | <ASSUME_GUARANTEE_T: "assume_guarentee">
 138 | <ATTRIBUTE_T: "attribute"> {::vhdl::parser::VhdlParser::setLineParsed(ATTRIBUTE_T);}
 139 | <BEGIN_T: "begin">
 140 | <BLOCK_T: "block">
 141 | <BODY_T: "body"> {::vhdl::parser::VhdlParser::setLineParsed(BODY_T);}
 142 | <BUFFER_T: "buffer">
 143 | <BUS_T: "bus">
 144 | <COMPONENT_T: "component"> {VhdlParser::setLineParsed(COMPONENT_T);}
 145 | <CASE_T: "case">
 146 | <CONFIGURATION_T: "configuration"> {VhdlParser::setLineParsed(CONFIGURATION_T);}
 147 | <CONSTANT_T: "constant">  {VhdlParser::setLineParsed(CONSTANT_T);}
 148 | <CONTEXT_T: "context"> {VhdlParser::setLineParsed(CONTEXT_T);}
 149 | <COVER_T: "cover">
 150 | <DEFAULT_T: "default">
 151 | <DISCONNECT_T: "disconnect">
 152 | <DOWNTO_T: "downto">
 153 | <ELSE_T: "else">
 154 | <ELSIF_T: "elsif">
 155 | <END_T: "end"> {VhdlParser::setLineParsed(END_T);}
 156 | <ENTITY_T: "entity"> {VhdlParser::setLineParsed(ENTITY_T);}
 157 | <EXIT_T: "exit">
 158 | <FAIRNESS_T: "fairness">
 159 | <FILE_T: "file"> {VhdlParser::setLineParsed(FILE_T);}
 160 | <FOR_T: "for">
 161 | <FORCE_T: "force">
 162 | <FUNCTION_T: "function">  {VhdlParser::setLineParsed(FUNCTION_T);}
 163 | <GENERATE_T: "generate">
 164 | <GENERIC_T: "generic">
 165 | <GROUP_T: "group"> {VhdlParser::setLineParsed(GROUP_T);}
 166 | <GUARDED_T: "guarded">
 167 | <IF_T: "if">
 168 | <IMPURE_T: "impure">
 169 | <IN_T: "in">
 170 | <INERTIAL_T: "inertial">
 171 | <INOUT_T: "inout">
 172 | <IS_T: "is">
 173 | <LABEL_T: "label">
 174 | <LIBRARY_T: "library"> {VhdlParser::setLineParsed(LIBRARY_T);}
 175 | <LINKAGE_T: "linkage">
 176 | <LITERAL_T: "literal">
 177 | <LOOP_T: "loop">
 178 | <MAP_T: "map">
 179 | <MOD_T: "mod">
 180 | <NAND_T: "nand">
 181 | <NEW_T: "new">
 182 | <NEXT_T: "next">
 183 | <NOR_T: "nor">
 184 | <NOT_T: "not">
 185 | <NULL_T: "null">
 186 | <OF_T: "of">
 187 | <ON_T: "on">
 188 | <OPEN_T: "open">
 189 | <OR_T: "or">
 190 | <OTHER_T: "others">
 191 | <OUT_T: "out">
 192 | <PACKAGE_T: "package"> {::vhdl::parser::VhdlParser::setLineParsed(PACKAGE_T);}
 193 | <PARAMETER_T: "parameter">
 194 | <PORT_T: "port"> {::vhdl::parser::VhdlParser::setLineParsed(PORT_T);}
 195 | <POSTPONED_T: "postponed">
 196 | <PROCEDURE_T: "procedure"> {::vhdl::parser::VhdlParser::setLineParsed(PROCEDURE_T);}
 197 | <PROCESS_T: "process"> {::vhdl::parser::VhdlParser::setLineParsed(PROCESS_T);}
 198 | <PROPERTY_T: "property">
 199 | <PROTECTED_T: "protected">
 200 | <PURE_T: "pure">
 201 | <RANGE_T: "range">
 202 | <RECORD_T: "record"> {::vhdl::parser::VhdlParser::setLineParsed(RECORD_T);}
 203 | <REGISTER_T: "register">
 204 | <REJECT_T: "reject">
 205 | <RELEASE_T: "release">
 206 | <RESTRICT_T: "restrict">
 207 | <RESTRICT_GUARANTEE_T: "restrict_guarantee">
 208 | <REM_T: "rem">
 209 | <REPORT_T: "report">
 210 | <ROL_T: "rol">
 211 | <ROR_T: "ror">
 212 | <RETURN_T: "return">
 213 | <SELECT_T: "select">
 214 | <SEQUENCE_T: "sequence">
 215 | <SEVERITY_T: "severity">
 216 | <SIGNAL_T: "signal"> {::vhdl::parser::VhdlParser::setLineParsed(SIGNAL_T);}
 217 | <SHARED_T: "shared">
 218 | <SLA_T: "sla">
 219 | <SLL_T: "sll">
 220 | <SRA_T: "sra">
 221 | <SRL_T: "srl">
 222 | <STRONG_T: "strong">
 223 | <SUBTYPE_T: "subtype"> {::vhdl::parser::VhdlParser::setLineParsed(SUBTYPE_T);}
 224 | <THEN_T: "then">
 225 | <TO_T: "to">
 226 | <TRANSPORT_T: "transport">
 227 | <TYPE_T: "type"> {::vhdl::parser::VhdlParser::setLineParsed(TYPE_T);}
 228 | <UNAFFECTED_T: "unaffected">
 229 | <UNITS_T: "units"> {::vhdl::parser::VhdlParser::setLineParsed(UNITS_T);}
 230 | <UNTIL_T: "until">
 231 | <USE_T: "use">
 232 | <VARIABLE_T: "variable">
 233 | <VMODE_T: "vmode">
 234 | <VPROP_T: "vprop">
 235 | <VUNIT_T: "vunit">
 236 | <WAIT_T: "wait">
 237 | <WHEN_T: "when">
 238 | <WHILE_T: "while">
 239 | <WITH_T: "with">
 240 | <XOR_T: "xor">
 241 | <XNOR_T: "xnor">
 242 }
 243
 244 /* OPERATORS */
 245
 246 TOKEN :
 247 {
 248   < AMPERSAND_T: "&" >
 249 | < APOSTROPHE_T: "'" >
 250 | < LPAREN_T: "(" >
 251 | < RPAREN_T: ")" >
 252 | < DOUBLEMULT_T: "**" >
 253 | < MULT_T: "*" >
 254 | < PLUS_T: "+" >
 255 | < MINUS_T: "-" >
 256 | < COMMA_T: "," >
 257 | < VARASSIGN_T: ":=" >
 258 | < COLON_T: ":" >
 259 | < SEMI_T: ";" >{::vhdl::parser::VhdlParser::setLineParsed(SEMI_T);}
 260 | < LESSTHAN_T: "<=" >
 261 | < GREATERTHAN_T: ">=" >
 262 | < LT_T: "<" >
 263 | < GT_T: ">" >
 264 | < EQU_T: "=" >
 265 | < NOTEQU_T: "/=" >
 266 | < ARROW_T: "=>" >
 267 | < BOX_T: "<>" >
 268 | < SLSL_T: "<<" >
 269 | < RSRS_T: ">>" >
 270 | < QQ_T: "??" >
 271 | < QGT_T: "?>=" >
 272 | < QLT_T: "?<=" >
 273 | < QG_T: "?>" >
 274 | < QL_T: "?<" >
 275 | < QEQU_T: "?=" >
 276 | < QNEQU_T: "?/=" >
 277 | < Q_T: "?" >
 278 | < BAR_T: "|" >
 279 | <DOT_T: "." >
 280 | < SLASH_T: "/" >
 281 | < AT_T: "@" >
 282 | < NEG_T: "^" >
 283 | < LBRACKET_T: "[" >
 284 | < RBRACKET_T: "]" >
 285 | < LBRACE: "{" >
 286 | < RBRACE: "}" >
 287
 288 }
 289
 290 TOKEN:
 291 {
 292   <INTEGER: <DIGIT> ((["_"])? (<DIGIT>))* >
 293  | <STRINGLITERAL: (( ["\""](<GRAPHIC_CHARACTER>)*) "\"")+ >
 294  | <BASIC_IDENTIFIER:  (<LETTER> ( (["_"])* <LETTER_OR_DIGIT> )*) >
 295  | <EXTENDED_CHARACTER: ( ["\\"](<GRAPHIC_CHARACTER>)*["\\"] ) >
 296  | <CHARACTER_LITERAL: (["'"](<GRAPHIC_CHARACTER>|<QUOTE>)["'"]) >
 297  | <DECIMAL_LITERAL: (<INTEGER> (["."]<INTEGER>)? (<EXPONENT>)? ) >
 298  | <BASED_INTEGER: <LETTER_OR_DIGIT>( <LETTER_OR_DIGIT>)* >
 299  | <BASED_LITERAL: <INTEGER>["#"]<BASED_INTEGER>(["."] <BASED_INTEGER>)? ["#"] (<EXPONENT>)? >
 300  | <#EXPONENT: (["e","E"] (["+","-"])? (<INTEGER>)+) >
 301  | < #BASIC_GRAPHIC_CHARACTER:    (<UPPER_CASE_LETTER>|<DIGIT>|<SPECIAL_CHARACTER>|<SPACE_CHARACTER>) >
 302  | < #GRAPHIC_CHARACTER: ( <BASIC_GRAPHIC_CHARACTER>|<LOWER_CASE_LETTER>|<OTHER_SPECIAL_CHARACTER> ) >
 303  | < #LETTER_OR_DIGIT: ( <LETTER> | <DIGIT> ) >
 304  | < #LETTER_OR_DIGIT_OR_STD: (<LETTER_OR_DIGIT> | <STD_LOGIC> ) >
 305  | < #LETTER: (<UPPER_CASE_LETTER>|<LOWER_CASE_LETTER>) >
 306  | < #UPPER_CASE_LETTER: ["A"-"Z"]  >
 307  | <BIT_STRING_LITERAL : (<DIGIT>)*<BASE_SPECIFIER>["\""](<LETTER_OR_DIGIT_OR_STD>((["_"])*<LETTER_OR_DIGIT_OR_STD>)*)["\""] >
 308  | <#BASE_SPECIFIER:["B","O","X","b","o","x","d","D"]>
 309  | <#STD_LOGIC:["0","1","L","H","X","Z","W","-","l","h","x","z","w"]>
 310  | < #DIGIT: ["0"-"9"] >
 311  | < #SPECIAL_CHARACTER: ["#","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","_","|"] >
 312  | < #OTHER_SPECIAL_CHARACTER: ["%","!","$","@","?","[","\\","]","^","`","{","}","~","\u00A0"-"\u00FF"]>
 313  | < #SPACE_CHARACTER: [" ","\t"] >
 314  | < #LOWER_CASE_LETTER: ["a"-"z"] >
 315  | < #QUOTE: ["\""] >
 316  | <VHDL2008TOOLDIR  : ["`"](<GRAPHIC_CHARACTER>|<STRINGLITERAL>)+ >
 317
 318 }
 319
 320 QCString abstract_literal() :
 321 {Token *tok;}
 322 {
 323    tok=<DECIMAL_LITERAL> { return tok->image.c_str(); }
 324  | tok=<INTEGER>         { return tok->image.c_str(); }
 325  | tok=<BASED_LITERAL>   { return tok->image.c_str(); }
 326 }
 327
 328 QCString access_type_definition() :
 329 {Token *tok=0;QCString str,str1;}
 330 {
 331   tok=<ACCESS_T> str1=subtype_indication() { str=tok->image.c_str(); return str+str1; }
 332 }
 333
 334 QCString actual_designator() :
 335 {QCString str;Token *t=0;}
 336 {
 337 t=<OPEN_T> { return t->image.c_str(); }
 338 |
 339 LOOKAHEAD(expression())
 340   str=expression() { return str; }
 341 |
 342   LOOKAHEAD(name())
 343  str=name() { return str; }
 344 }
 345
 346 QCString actual_parameter_part() :
 347 {QCString s;}
 348 {
 349    s=association_list() { return s;}
 350 }
 351
 352 QCString actual_part() :
 353 {QCString s,s1;}
 354 {
 355  LOOKAHEAD(actual_designator())
 356  s=actual_designator() { return s;}
 357  |
 358    <BOX_T> { return "<>";}
 359  |
 360  s=name() <LPAREN_T> s1=actual_designator() <RPAREN_T> {s+="(";s+=s1+")";return s;}
 361
 362  }
 363
 364 QCString adding_operator () :
 365 {}
 366 {
 367   <PLUS_T> { return "+";}
 368   | <MINUS_T> { return "-";}
 369   |<AMPERSAND_T> { return "&";}
 370 }
 371
 372 QCString aggregate() :  {QCString s,s1,s2;}
 373 {
 374   <LPAREN_T> s=element_association() (<COMMA_T> s1=element_association(){s+=","+s1;})* <RPAREN_T> { return "("+s+")";}
 375 }
 376
 377 QCString alias_declaration() :  {QCString s,s1,s2;}
 378 {
 379  <ALIAS_T> s2=alias_designator()
 380  [ <COLON_T>{ s+=":"; } s1=subtype_indication() { s+=s1; }]
 381  <IS_T> { s+=" is "; } s1=name() {s+=s1;} [s1=signature() {s+=s1;}]
 382  <SEMI_T>
 383 {
 384  addVhdlType(s2.data(),getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public);
 385
 386  return s2+" "+s+";";
 387 }
 388  }
 389
 390 QCString alias_designator()  : {Token *tok=0;QCString s;}
 391 {
 392  s=identifier() { return s;}
 393  | tok=<CHARACTER_LITERAL> { return tok->image.c_str(); }
 394  | s=operator_symbol() { return s; }
 395 }
 396
 397 void allocator()  :{}
 398 {
 399  LOOKAHEAD(3)
 400  <NEW_T> qualified_expression()
 401  |  <NEW_T>  subtype_indication()
 402 }
 403
 404 void architecture_body() : {QCString s,s1;}
 405 {
 406
 407     <ARCHITECTURE_T> s=identifier() <OF_T> s1=name() <IS_T>
 408     {
 409                   QCString t=s1+"::"+s;
 410                   genLabels.resize(0);
 411                   pushLabel(genLabels,s1);
 412                   lastCompound=current;
 413                   addVhdlType(t,getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private);
 414     }
 415    try{
 416    architecture_declarative_part()
 417     }catch(...){error_skipto(BEGIN_T);}
 418    <BEGIN_T>
 419    architecture_statement_part()
 420   <END_T> [<ARCHITECTURE_T>] [name()] <SEMI_T>
 421    { lastEntity=0;lastCompound=0; genLabels.resize(0); }
 422 }
 423
 424 void architecture_declarative_part() : {}
 425 {
 426   (block_declarative_item() )*
 427  // | (<VHDL2008TOOLDIR>)
 428 }
 429
 430 void architecture_statement_part() :  {}
 431 {
 432   (concurrent_statement())*
 433  // | (<VHDL2008TOOLDIR>)
 434 }
 435
 436 QCString array_type_definition ():  { QCString s;}
 437 {
 438
 439  LOOKAHEAD(unconstraint_array_definition())
 440
 441   s=unconstraint_array_definition() {return s;}
 442   | s=constraint_array_definition()  {return s;}
 443
 444 }
 445
 446 QCString assertion() :  {QCString s,s1,s2;Token *t=0;Token *t1=0;}
 447 {
 448    <ASSERT_T> s=condition() [ t=<REPORT_T> s1=expression() ] [t1=<SEVERITY_T> s2=expression()]
 449  {
 450    s.prepend("assert ");
 451    if(t) s1.prepend(" report ");
 452    if(t1) s2.prepend(" report ");
 453     return s+s1+s2;
 454  }
 455 }
 456
 457 QCString assertion_statement() :  {QCString s,s1,s2;Token *t=0;}
 458 {
 459   [ s=label() t=<COLON_T> ] s1=assertion() <SEMI_T>
 460   {
 461     if(t) s+=":";
 462     return s+s1+";";
 463   }
 464 }
 465 QCString association_element() : {QCString s,s1;}
 466 {
 467  [LOOKAHEAD(formal_part() <ARROW_T>) s=formal_part() <ARROW_T> ] s1=actual_part()
 468  { return s+" => "+s1;}
 469 }
 470
 471 QCString association_list ():  {QCString s,s1;}
 472 {
 473 s=association_element() (<COMMA_T> s1=association_element() { s+=","+s1; })* { return s; }
 474 }
 475
 476 QCString attribute_declaration() : {QCString s,s1;}
 477 {
 478  <ATTRIBUTE_T> s=identifier() <COLON_T> s1=type_mark() <SEMI_T>
 479   {
 480     addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public);
 481     return " attribute "+s+":"+s1+";";
 482   }
 483  }
 484
 485 QCString attribute_designator (): {QCString s;Token *tok=0;}
 486 {
 487   s=identifier() { return s;}
 488   | tok=<RANGE_T> { return tok->image.c_str(); }
 489 }
 490
 491 QCString attribute_name (): {QCString s,s1;}
 492 {
 493   s=identifier() <APOSTROPHE_T> s1=name(){ s+="'"+s1; }[LOOKAHEAD(1)<LPAREN_T>s1=expression() <RPAREN_T> {s+"("+s1+")";}] { return s; }
 494 }
 495
 496
 497 QCString attribute_specification():  {QCString s,s1,s2;}
 498 {
 499   <ATTRIBUTE_T> s=attribute_designator() <OF_T> s1=entity_specification() <IS_T> s2=expression() <SEMI_T>
 500   {
 501    QCString t= s1+" is "+s2;
 502    addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public);
 503    return " attribute "+s+" of "+s1+ " is "+s2+";";
 504   }
 505 }
 506
 507 QCString base() :  {Token *tok=0;}
 508 {
 509   tok=<INTEGER> { return tok->image.c_str();}
 510 }
 511
 512 QCString base_specifier ():  {Token *tok=0;}
 513 {
 514    tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}
 515 }
 516
 517 QCString base_unit_declaration() :
 518 {QCString s;}
 519 {
 520   s=identifier() { return s; }
 521 }
 522
 523 QCString based_integer() :  {Token *tok=0;}
 524 {
 525   tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}
 526 }
 527
 528 QCString based_literal():  {Token *tok=0;}
 529 {
 530  tok=<BASED_LITERAL> { return tok->image.c_str();}
 531 }
 532
 533 QCString basic_identifier() :  {Token *tok=0;}
 534 {
 535   tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}
 536 }
 537
 538 void binding_indication() :  {}
 539 {
 540  [ <USE_T> entity_aspect() ]
 541  [ generic_map_aspect() ]
 542  [ port_map_aspect() ]
 543 }
 544
 545 QCString bit_string_literal ():  {Token *tok=0;}
 546 {
 547   tok=<BIT_STRING_LITERAL> { return tok->image.c_str();}
 548 }
 549
 550
 551 QCString bit_value() :  {Token *tok=0;}
 552 {
 553   tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}
 554 }
 555
 556 void block_configuration() : {}
 557 {
 558     <FOR_T> block_specification()
 559         ( use_clause() )*
 560         ( configuration_item())*
 561     <END_T> <FOR_T> <SEMI_T>
 562 }
 563
 564 void block_declarative_item ():  {}
 565 {
 566   subprogram_declaration()
 567 //| subprogram_body()
 568 | type_declaration()
 569 | subtype_declaration()
 570 | constant_declaration()
 571 | signal_declaration()
 572 | variable_declaration()
 573 | file_declaration()
 574 | alias_declaration()
 575 | component_declaration()
 576 |
 577 LOOKAHEAD(attribute_declaration())
 578 attribute_declaration()
 579 | attribute_specification()
 580 | configuration_specification()
 581 | disconnection_specification ()
 582 | use_clause()
 583 |
 584 LOOKAHEAD(3)
 585 group_template_declaration()
 586 | group_declaration()
 587 //| <VHDL2008TOOLDIR>
 588 }
 589
 590 void block_declarative_part() : {}
 591 {
 592    (block_declarative_item() )*
 593 }
 594
 595 void block_header() : {}
 596 {
 597 [LOOKAHEAD(generic_clause()) generic_clause()[ generic_map_aspect() <SEMI_T> ] ]
 598 [ port_clause() [ port_map_aspect() <SEMI_T> ] ]
 599 }
 600
 601 void block_specification() :  {}
 602 {
 603   name()[LOOKAHEAD(1) <LPAREN_T> index_specification() <RPAREN_T>]
 604 }
 605
 606 void block_statement() :  {QCString s;}
 607 {
 608   s=identifier() <COLON_T>
 609         <BLOCK_T> { pushLabel(genLabels,s); }[ <LPAREN_T> expression() <RPAREN_T> ] [ <IS_T> ]
 610             block_header()
 611             block_declarative_part()
 612             <BEGIN_T>
 613             block_statement_part()
 614             <END_T> <BLOCK_T> [ identifier() ] <SEMI_T>
 615             {
 616               genLabels=popLabel(genLabels);
 617             }
 618 }
 619
 620 void block_statement_part() :  {}
 621 {
 622   ( concurrent_statement() )*
 623 }
 624
 625 void  case_statement() : {QCString s;}
 626 {
 627 [ identifier() <COLON_T> ]
 628   <CASE_T> s=expression()
 629     {
 630      QCString ca="case "+s;
 631      FlowChart::addFlowChart(FlowChart::CASE_NO,0,ca);
 632     }
 633   <IS_T>
 634         case_statement_alternative()
 635         ( case_statement_alternative ())*
 636         <END_T> <CASE_T> [ identifier() ] <SEMI_T>
 637         {
 638          FlowChart::moveToPrevLevel();
 639          FlowChart::addFlowChart(FlowChart::END_CASE,"end case",0);
 640           }
 641 }
 642
 643 void case_statement_alternative() :  {QCString s;}
 644 {
 645   <WHEN_T> s=choices() <ARROW_T>
 646    {
 647     QCString t="when ";
 648     t+=s+"=> ";
 649     FlowChart::addFlowChart(FlowChart::WHEN_NO,s.data(),t);
 650     }
 651   sequence_of_statement(){FlowChart::moveToPrevLevel(); }
 652 }
 653
 654 QCString character_literal() :  {Token *tok=0;}
 655 {
 656   tok=<CHARACTER_LITERAL>{ return tok->image.c_str();}
 657 }
 658
 659 QCString choice() : {QCString s;}
 660 {
 661   LOOKAHEAD(discrete_range())
 662   s=discrete_range(){ return s; }
 663   |
 664    LOOKAHEAD(simple_expression())
 665    s=simple_expression(){ return s; }
 666   |
 667   LOOKAHEAD(identifier())
 668   s=identifier(){ return s; }
 669   | <OTHER_T> { return " others "; }
 670 }
 671
 672 QCString choices() :  {QCString s,s1;}
 673 {
 674   s=choice() (<BAR_T> s1=choice(){s+="|";s+=s1;})* { return s; }
 675 }
 676
 677 void component_configuration () :{}
 678 {
 679     <FOR_T> component_specification()
 680         [ binding_indication() <SEMI_T> ]
 681         [ block_configuration() ]
 682     <END_T> <FOR_T> <SEMI_T>
 683 }
 684 void component_declaration() :  {QCString s;}
 685 {
 686  <COMPONENT_T> s=identifier() [ <IS_T> ]
 687    { currP=VhdlDocGen::COMPONENT; }
 688   [ generic_clause() ]
 689   [ port_clause() ]
 690    {
 691      addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public);
 692      currP=0;
 693   }
 694   <END_T> <COMPONENT_T> [ identifier() ] <SEMI_T>
 695
 696 }
 697
 698 void component_instantiation_statement() :  {QCString s,s1;}
 699 {
 700
 701 s=identifier() <COLON_T>
 702  s1=instantiation_unit()
 703  {
 704        QCString s3;
 705        if (s1.contains("|")) {
 706          s3=VhdlDocGen::getIndexWord(s1.data(),0);
 707          s1=VhdlDocGen::getIndexWord(s1.data(),1);
 708        }
 709
 710        addCompInst(s.lower().data(),s1.lower().data(),s3.data(),getLine());
 711  }
 712         [ LOOKAHEAD(generic_map_aspect()) generic_map_aspect() ]
 713         [ port_map_aspect() ] <SEMI_T>
 714 }
 715
 716 void component_specification() :  {}
 717 {
 718 instantiation_list() <COLON_T> name()
 719 }
 720
 721 QCString composite_type_definition() :  { QCString s,s1;}
 722 {
 723  s=array_type_definition(){ return s; }
 724 | record_type_definition(){ return s+"#"; }
 725 }
 726
 727 void concurrent_assertion_statement() :  {}
 728 {
 729 [  LOOKAHEAD(2) identifier() <COLON_T> ] [  <POSTPONED_T> ] assertion() <SEMI_T>
 730 }
 731
 732 void concurrent_procedure_call_statement() :  {}
 733 {
 734 [  LOOKAHEAD(2) identifier() <COLON_T> ] [ <POSTPONED_T> ] procedure_call() <SEMI_T>
 735 }
 736
 737 void concurrent_signal_assignment_statement() :  {}
 738 {
 739 [ LOOKAHEAD(2) identifier() <COLON_T> ] [<POSTPONED_T> ]
 740 (
 741 LOOKAHEAD(conditional_signal_assignment() )
 742  conditional_signal_assignment()
 743 | selected_signal_assignment()
 744
 745 )
 746 }
 747
 748 void concurrent_statement() :  {}
 749 {
 750
 751 // try {
 752 LOOKAHEAD([identifier() ":"] <BLOCK_T>)
 753 block_statement()
 754 |
 755 LOOKAHEAD([identifier() ":"] [<POSTPONED_T>] <PROCESS_T>)
 756 process_statement()
 757 |
 758 LOOKAHEAD(generate_statement())
 759 generate_statement()
 760 |
 761 case_scheme()
 762 |
 763 LOOKAHEAD([identifier() ":"] [<POSTPONED_T>] <ASSERT_T>)
 764 concurrent_assertion_statement()
 765 |
 766 LOOKAHEAD(concurrent_signal_assignment_statement())
 767     concurrent_signal_assignment_statement()
 768 |
 769 LOOKAHEAD(component_instantiation_statement() )
 770 component_instantiation_statement()
 771 |
 772 LOOKAHEAD(concurrent_procedure_call_statement())
 773 concurrent_procedure_call_statement()
 774 | <VHDL2008TOOLDIR>
 775  /*
 776   catch( ParseException e )
 777   {
 778     error_skipto(SEMI_T, "syntax error in declarative item");
 779   }
 780  */
 781 }
 782
 783 QCString condition() :  {QCString s;}
 784 {
 785   s=expression() { return s; }
 786 }
 787
 788 QCString condition_clause() :  {QCString s;}
 789 {
 790   <UNTIL_T> s=condition()
 791   {
 792     return " until "+s;
 793   }
 794 }
 795
 796 void conditional_signal_assignment() :  {}
 797 {
 798   // LOOKAHEAD(  target() "<=" options_() conditional_waveforms() ";")
 799  target() <LESSTHAN_T> options() conditional_waveforms() <SEMI_T>
 800 }
 801
 802 void conditional_waveforms() :  {}
 803 {
 804 waveform()
 805     ( LOOKAHEAD(<WHEN_T> condition() <ELSE_T>)
 806        <WHEN_T> condition() <ELSE_T> waveform() )*
 807     [ <WHEN_T> condition() ]
 808 }
 809
 810 // ( waveform() < WHEN_T> condition() <ELSE_T> )*
 811 //   waveform() [ <WHEN_T> condition() ]
 812
 813 //waveform()
 814  //   ( LOOKAHEAD( <WHEN> condition() <ELSE>)
 815     //    <WHEN> condition() <ELSE> waveform() )*
 816     //[ <WHEN> condition() ]
 817
 818 void configuration_declaration() :  {QCString s,s1;}
 819 {
 820  <CONFIGURATION_T> s=identifier() <OF_T> s1=name() <IS_T>
 821   {
 822
 823   confName=s+"::"+s1;
 824   addVhdlType(s.data(),getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public);
 825   }
 826     configuration_declarative_part()
 827     block_configuration()
 828  <END_T> [ <CONFIGURATION_T> ] [ name() ] <SEMI_T>
 829  { genLabels.resize(0); confName="";}
 830 }
 831
 832 void configuration_declarative_item() : {}
 833 {
 834  use_clause()
 835 | attribute_specification()
 836 | group_declaration()
 837 }
 838
 839 void configuration_declarative_part() :  {}
 840 {
 841  (configuration_declarative_item())*
 842 }
 843
 844 void configuration_item ():  {}
 845 {
 846  LOOKAHEAD(component_configuration())
 847  component_configuration()
 848  | block_configuration()
 849
 850 }
 851
 852 void configuration_specification() :  {}
 853 {
 854 <FOR_T> component_specification() binding_indication() <SEMI_T>
 855 }
 856
 857 QCString constant_declaration() :  {QCString s,s1,s2;Token *t=0;}
 858 {
 859    <CONSTANT_T> s=identifier_list() <COLON_T> s1= subtype_indication() [ t=<VARASSIGN_T> s2=expression() ] <SEMI_T>
 860     {
 861      if(t)
 862       s2.prepend(":=");
 863      QCString it=s1+s2;
 864      addVhdlType(s.data(),getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public);
 865      it.prepend("constant ");
 866      return it;
 867     }
 868 }
 869
 870 QCString constraint_array_definition (): {QCString s,s1;}
 871 {
 872 <ARRAY_T> s=index_constraint() <OF_T> s1=subtype_indication(){ return s+" "+s1;}
 873 }
 874
 875 void context_clause (): {}
 876 {
 877  (context_item())*
 878 }
 879
 880 QCString constraint () :{QCString s;}
 881  {
 882     LOOKAHEAD(range_constraint())
 883     s=range_constraint(){ return s;}
 884     |
 885     LOOKAHEAD(index_constraint())
 886      s=index_constraint(){ return s;}
 887 }
 888
 889 void context_item() :  {}
 890 {
 891  library_clause()
 892 | use_clause()
 893 }
 894
 895 QCString decimal_literal() :  {Token *tok=0;}
 896 {
 897  tok=<DECIMAL_LITERAL> { return tok->image.c_str(); }
 898 }
 899
 900
 901 QCString delay_mechanism ():  {QCString s;}
 902 {
 903 <TRANSPORT_T> { return " transport ";}
 904 | [ <REJECT_T> s=expression() {s.prepend(" reject ");}] <INERTIAL_T> { return s+" inertial "; }
 905 }
 906
 907 void design_file() :  {}
 908 {
 909   (design_unit() )+  {}
 910   | <EOF>
 911 }
 912
 913 void design_unit() :  {}
 914 {
 915  context_clause()library_unit()
 916
 917 }
 918
 919 QCString designator() : {QCString s;}
 920 {
 921  s=identifier()          {return s;}
 922  | s=operator_symbol(){return s;}
 923 }
 924
 925 QCString direction ():  {Token *tok=0;}
 926 {
 927 tok=<TO_T>  { return tok->image.c_str();}
 928 | tok=<DOWNTO_T> { return tok->image.c_str();}
 929 }
 930
 931 void disconnection_specification() : {}
 932 {
 933 <DISCONNECT_T> guarded_signal_specificatio() <AFTER_T> expression() <SEMI_T>
 934 }
 935
 936 void guarded_signal_specificatio() : {}
 937 {
 938  signal_list() <COLON_T> name()
 939 }
 940
 941 QCString discrete_range() : {QCString s;}
 942 {
 943   LOOKAHEAD(range())
 944   s=range() { return s;}
 945   |
 946   LOOKAHEAD(subtype_indication())
 947    s=subtype_indication() { return s;}
 948 }
 949
 950 QCString element_association() :  {QCString s,s1;}
 951 {
 952 [LOOKAHEAD(choices() <ARROW_T>) s=choices() <ARROW_T> ]  s1=expression()
 953  {
 954 if(!s.isEmpty())
 955  return s+"=>"+s1;
 956 return s1;
 957  }
 958 }
 959
 960 QCString element_declaration() :  {QCString s,s1;}
 961 {
 962 s=identifier_list() <COLON_T> s1=subtype_indication() <SEMI_T>
 963 {
 964
 965   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s1.data(),Public);
 966   //addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
 967   return s+":"+s1;
 968 }
 969 }
 970
 971
 972 QCString entity_aspect() :  {Token *tok=0;QCString s,s1;}
 973 {
 974 tok=<ENTITY_T> s=name() [ LOOKAHEAD(1)<LPAREN_T> s1=identifier() <RPAREN_T> {s+="("+s1+")";} ] { return s;}
 975 | tok=<CONFIGURATION_T> s=name() { return tok->image.c_str()+s;}
 976 | tok=<OPEN_T> { return tok->image.c_str(); }
 977 }
 978
 979 QCString entity_class() :  {}
 980 {
 981 <ENTITY_T> { return "entity";}
 982 | <ARCHITECTURE_T> {return "architecture";}
 983 | <CONFIGURATION_T> {return "configuration";}
 984 | <PROCEDURE_T> {return "procedure";}
 985 | <FUNCTION_T> {return "function";}
 986 | <PACKAGE_T> {return "package";}
 987 | <TYPE_T> {return "type";}
 988 | <SUBTYPE_T> {return "subtype";}
 989 | <CONSTANT_T> {return "constant";}
 990 | <SIGNAL_T> {return "signal";}
 991 | <VARIABLE_T> {return "variable";}
 992 | <COMPONENT_T> {return "component";}
 993 | <LABEL_T> {return "label";}
 994 | <LITERAL_T> {return "literal";}
 995 | <UNITS_T> {return "units";}
 996 | <GROUP_T> {return "group";}
 997 | <FILE_T>  {return "file";}
 998 }
 999
1000 QCString entity_class_entry() :  {QCString s;}
1001 {
1002  s=entity_class() [ <BOX_T> {s+="<>";} ] { return s;}
1003 }
1004
1005 QCString entity_class_entry_list() :  {QCString s,s1,s2;}
1006 {
1007  ( s1=entity_class_entry() {s+=s1;} )(<COMMA_T> s=entity_class_entry(){s2+=",";s2+=s;}  )* { return s1+s2;}
1008 }
1009
1010 void entity_declaration() :  {QCString s;}
1011 {
1012    // try{
1013     <ENTITY_T> s=identifier()  <IS_T>
1014              {
1015                 lastEntity=current;
1016                 lastCompound=0;
1017                 addVhdlType(s.data(),getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public);
1018                }
1019         entity_header()
1020         entity_declarative_part ()
1021       [ <BEGIN_T> entity_statement_part() ]
1022        <END_T> [ <ENTITY_T> ] [ name() ]
1023      //    }catch(...){error_skipto(SEMI_T);}
1024      <SEMI_T>
1025      { lastEntity=0;lastCompound=0; genLabels.resize(0); }
1026 }
1027
1028 void entity_declarative_item() : {}
1029 {
1030 subprogram_declaration()
1031 //| subprogram_body()
1032 | type_declaration()
1033 | subtype_declaration()
1034 | constant_declaration()
1035 | signal_declaration()
1036 | variable_declaration()
1037 | file_declaration()
1038 | alias_declaration()
1039 |
1040 LOOKAHEAD(attribute_declaration())
1041 attribute_declaration()
1042 | attribute_specification()
1043 | disconnection_specification()
1044 | use_clause()
1045 |
1046 LOOKAHEAD(3)
1047 group_template_declaration()
1048 | group_declaration()
1049 |
1050 LOOKAHEAD(5)
1051  package_instantiation_declaration()
1052 |package_declaration()
1053 | <VHDL2008TOOLDIR>
1054 }
1055
1056 void entity_declarative_part() : {}
1057 {
1058   (entity_declarative_item() )*
1059 }
1060
1061 QCString entity_designator() :  {QCString s,s1;}
1062 {
1063 s=entity_tag() [ s1=signature() ] { return s+s1;}
1064 }
1065
1066 void entity_header() : {}
1067 {
1068  [  { currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC; } generic_clause()]
1069  [ { currP=VhdlDocGen::PORT; } port_clause()]
1070 }
1071
1072 QCString entity_name_list() :  {QCString s,s1;}
1073 {
1074 (s1=entity_designator() {s+=s1;})+ { return s;}
1075 | <OTHER_T> { return "other";}
1076 | <ALL_T> {return "all";}
1077 }
1078
1079 QCString entity_specification() :  {QCString s,s1;}
1080 {
1081 s=entity_name_list() <COLON_T> s1=entity_class(){ return s+":"+s1;}
1082 }
1083
1084 void entity_statement() :  {}
1085 {
1086 LOOKAHEAD(concurrent_assertion_statement())
1087 concurrent_assertion_statement()
1088 |
1089 LOOKAHEAD(process_statement())
1090  process_statement()
1091 | concurrent_procedure_call_statement()
1092
1093 }
1094
1095 void entity_statement_part() :  {}
1096 {
1097  (entity_statement())*
1098 }
1099
1100
1101 QCString entity_tag ():  {QCString s;}
1102 {
1103 s=name() { return s;}
1104 | s=character_literal() { return s;}
1105 }
1106
1107 QCString enumeration_literal() :  {QCString s;}
1108 {
1109  s=identifier() { return s;}
1110  | s=character_literal() { return s;}
1111 }
1112
1113 QCString enumeration_type_definition() : {QCString s,s1;}
1114 {
1115   <LPAREN_T>s=enumeration_literal() (LOOKAHEAD(1)<COMMA_T> s1=enumeration_literal() {s+=",";s+=s1;} )* <RPAREN_T>
1116   { return "("+s+")";}
1117 }
1118
1119 QCString exit_statement() :  {QCString s,s1,s2;Token *t=0;Token *t1=0;}
1120 {
1121 [ s=identifier() t=<COLON_T> ] <EXIT_T> [ s1=identifier() ]
1122 [ t1=<WHEN_T> s2=condition() ] <SEMI_T>
1123 {
1124   lab.resize(0);
1125   if(t) s+=":";
1126   if(t1) s2.prepend(" when ");
1127    FlowChart::addFlowChart(FlowChart::EXIT_NO,"exit",s2.data(),s1.data());
1128
1129   return s+s1+s2+";";
1130 }
1131 }
1132
1133 QCString expression ():  {QCString s,s1,s2;}
1134 {
1135 s=relation() ( s1=logop() s2=relation() {s+=s1;s+=s2;} )*
1136 { return s; }
1137 }
1138
1139 QCString logop() : {}
1140 {
1141   <AND_T> { return "and" ;}
1142   |<NAND_T> { return "nand" ;}
1143   |<NOR_T> { return "nor" ;}
1144   |<XNOR_T> { return "xnor" ;}
1145   |<XOR_T> { return "xor" ;}
1146   |<OR_T> { return "or" ;}
1147  }
1148
1149 QCString extended_identifier ():  {Token *t;}
1150 {
1151  t=<EXTENDED_CHARACTER> { return t->image.c_str(); }
1152 }
1153
1154 QCString factor():  {QCString s,s1;}
1155 {
1156 s=primary() [LOOKAHEAD(1) <DOUBLEMULT_T> s1=primary(){ s+="**";s+=s1;} ] { return s;}
1157 | <ABS_T> s=primary(){ s1 = "abs "; return s1+s; }
1158 | <NOT_T>  s=primary(){s1="not ";return s1+s;}
1159 }
1160
1161 QCString file_declaration() :  {QCString s,s1,s2,s3;}
1162 {
1163  <FILE_T> s=identifier_list() <COLON_T> s2=subtype_indication() [ s3=file_open_information() ] <SEMI_T>
1164    {
1165    QCString t1=s2+" "+s3;
1166    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public);
1167    return " file "+s+":"+s2+" "+s3+";";
1168    }
1169  }
1170
1171 QCString  file_logical_name():  {QCString s;}
1172 {
1173  s=expression() { return s; }
1174 }
1175
1176 QCString file_open_information() :  {QCString s,s1,s2;}
1177 {
1178  [ <OPEN_T> s=expression() ] <IS_T> s1=file_logical_name() {s2="open "+s+" is "+s1;  return s2; }
1179 }
1180
1181 QCString file_type_definition() :  {QCString s,s1;}
1182 {
1183  <FILE_T> <OF_T> s=type_mark() { s1=" file of "+s; return s1;}
1184 }
1185
1186 QCString floating_type_definition() :  {QCString s;}
1187 {
1188   s=range_constraint(){ return s;}
1189 }
1190
1191 QCString formal_designator() : {QCString s;Token *tok=0;}
1192 {
1193     s=name()  { return s; }
1194     |tok=<INTEGER> { return tok->image.c_str();}
1195 }
1196
1197
1198 QCString formal_parameter_list() :  {QCString s;}
1199 {
1200  s=interface_list(){ return s; }
1201 }
1202
1203 QCString formal_part() : {QCString s,s1;}
1204 {
1205 s=name() [<LPAREN_T> formal_designator() <RPAREN_T> {s+"("+s1+")";}] {return s;}
1206 }
1207
1208 QCString full_type_declaration() :  {Entry *tmpEntry;QCString s,s1,s2;}
1209 {
1210 <TYPE_T> s=identifier() <IS_T>
1211 {
1212   tmpEntry=current;
1213   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,0,Public);
1214 }
1215  try{
1216      s2=type_definition()
1217        }catch(...){error_skipto(SEMI_T);}
1218      <SEMI_T>
1219      {
1220       if (s2.contains("#")) {
1221         VhdlDocGen::deleteAllChars(s2,'#');
1222         tmpEntry->spec=VhdlDocGen::RECORD;
1223         tmpEntry->type=s2.data();
1224         //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::RECORD,0,s2.data(),Public);
1225       }
1226       else if (s2.contains("%")) {
1227         VhdlDocGen::deleteAllChars(s2,'%');
1228         tmpEntry->spec=VhdlDocGen::UNITS;
1229         tmpEntry->type=s2.data();
1230         //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,s2.data(),s2.data(),Public);
1231       }
1232       else {
1233         tmpEntry->spec=VhdlDocGen::TYPE;
1234         tmpEntry->type=s2.data();
1235         //addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public);
1236       }
1237       tmpEntry=0;
1238       return "type "+s+" is "+s2+";";
1239      }
1240 }
1241
1242 QCString function_call() :  {QCString s,s1;}
1243 {
1244 s=name()  <LPAREN_T> s1=actual_parameter_part()  <RPAREN_T> { return s+"("+s1+")";}
1245 }
1246
1247 void generate_statement() :  {QCString s;}
1248 {
1249 s=identifier() <COLON_T>
1250           try{
1251         generate_scheme() <GENERATE_T>
1252         { pushLabel(genLabels,s); }
1253           generate_statement_body1()
1254         <END_T>
1255                  }catch(...){error_skipto(GENERATE_T);}
1256         <GENERATE_T> [ identifier() ] <SEMI_T> {genLabels=popLabel(genLabels); }
1257 }
1258
1259 void generate_scheme() : {}
1260 {
1261 <FOR_T> parameter_specification()
1262 | <IF_T> condition()
1263 }
1264
1265 void generic_clause() : {QCString s;}
1266 {
1267  <GENERIC_T>  <LPAREN_T> { parse_sec=GEN_SEC; } s=generic_list() <RPAREN_T> <SEMI_T> { parse_sec=0; }
1268 }
1269
1270 QCString generic_list() :  {QCString s;}
1271 {
1272  s=interface_list() { return s; }
1273 }
1274
1275 void generic_map_aspect() :  {}
1276 {
1277      <GENERIC_T> <MAP_T> <LPAREN_T> association_list() <RPAREN_T>
1278 }
1279
1280 QCString group_constituent() :  {QCString s;}
1281 {
1282  s=name() { return s; }
1283  | s=character_literal() { return s;}
1284 }
1285
1286 QCString group_constituent_list() : {QCString s,s1,s2;}
1287 {
1288   (s1=group_constituent())(<COMMA_T> s=group_constituent(){s2+=",";s2+=s1;})* { return s+s2;}
1289 }
1290
1291 QCString group_declaration() :  {QCString s,s1,s2;}
1292 {
1293   <GROUP_T> s=identifier() <COLON_T> s1=identifier() <LPAREN_T> s2=group_constituent_list() <RPAREN_T> <SEMI_T>
1294   {
1295    return "group "+s+":"+s1+"("+s2+");";
1296   }
1297 }
1298
1299 QCString group_template_declaration() : {QCString s,s1;}
1300 {
1301  <GROUP_T> s=identifier() <IS_T> <LPAREN_T> s1=entity_class_entry_list() <RPAREN_T> <SEMI_T>
1302   {
1303     return "group "+s+ "is ("+s1+");";
1304   }
1305  }
1306
1307 void guarded_signal_specification() : {}
1308 {
1309  signal_list() <COLON_T> type_mark()
1310 }
1311
1312 QCString identifier() : {Token *tok=0;}
1313 {
1314   tok=<EXTENDED_CHARACTER>{ return tok->image.c_str(); }
1315   |tok=<BASIC_IDENTIFIER> { return tok->image.c_str(); }
1316 }
1317
1318 QCString identifier_list() : {QCString str,str1;}
1319 {
1320    str=identifier() (<COMMA_T> str1=identifier() {str+=",";str+=str1;})* { return str; }
1321 }
1322
1323 void if_statement() :  {QCString s,s1;}
1324 {
1325 [LOOKAHEAD(1) identifier() <COLON_T> ]
1326     <IF_T> s=condition() <THEN_T>
1327     {
1328     s.prepend("if ");
1329     FlowChart::addFlowChart(FlowChart::IF_NO,0,s);
1330   }
1331         sequence_of_statement()
1332         (
1333           <ELSIF_T> s1=condition() <THEN_T>
1334           {
1335            s1.prepend("elsif ");
1336            FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data());
1337           }
1338           sequence_of_statement()
1339         )*
1340         [LOOKAHEAD(1) <ELSE_T>
1341          {
1342            FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0);
1343          }
1344         sequence_of_statement() ] <END_T> <IF_T> [ identifier() ] <SEMI_T>
1345          {
1346           FlowChart::moveToPrevLevel();
1347           FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0);
1348         }
1349 }
1350
1351 QCString incomplete_type_declaration() :  {QCString s;}
1352 {
1353   <TYPE_T> s=identifier() <SEMI_T>
1354   {
1355    return "type "+s+";";
1356   }
1357 }
1358
1359 QCString index_constraint() :  {QCString s="("; QCString s1,s2;}
1360 {
1361   //try{
1362   <LPAREN_T> s2=discrete_range(){s+=s2;}(LOOKAHEAD(1)<COMMA_T> s1=discrete_range(){s+=",";s+=s1;})*  <RPAREN_T> {return s+")";}
1363 //}catch(...){  error_skipto(SEMI_T);hasError=false;return "";}
1364   }
1365
1366 QCString index_specification() : {QCString s;}
1367 {
1368  LOOKAHEAD( discrete_range())
1369  s=discrete_range() { return s;}
1370 | s=expression(){ return s;}
1371 }
1372
1373 QCString index_subtype_definition() :  {QCString s;}
1374 {
1375  s=type_mark() <RANGE_T> <BOX_T> { return s+" range <> ";}
1376 }
1377
1378 QCString instantiation_unit() :  {QCString s,s1,s2;Token *tok;}
1379 {
1380 [ <COMPONENT_T> ] s=identifier() {s1="component "; return s; }
1381 | <ENTITY_T>  [LOOKAHEAD(2)<BASIC_IDENTIFIER> <DOT_T>] s2=name() {s="entity|"+s2;} [ <LPAREN_T> s1=identifier() <RPAREN_T> {s+="(";s+=s1;s+=")" ;}] { return s;}
1382 | <CONFIGURATION_T> s=name() {s1="configuration ";return s;}
1383 }
1384
1385 QCString instantiation_list() : {QCString s;Token *tok=0;}
1386 {
1387   s=identifier_list() { return s;}
1388 | tok=<OTHER_T> {return tok->image.c_str();}
1389 | tok=<ALL_T> {return tok->image.c_str();}
1390 }
1391
1392 QCString integer() :  {Token *t;}
1393 {
1394   t=<INTEGER> {return t->image.c_str();}
1395 }
1396
1397 QCString integer_type_definition() :  {QCString s;}
1398 {
1399   s=range_constraint(){ return s;}
1400 }
1401
1402 QCString interface_declaration() :  {QCString s,s1;}
1403 {
1404
1405 LOOKAHEAD(5)
1406  s=interface_subprogram_declaration() { return s;}
1407
1408 |interface_package_declaration() { return s;}
1409 |
1410  LOOKAHEAD(5)
1411  s=interface_variable_declaration() { return s;}
1412 |
1413 LOOKAHEAD(5)
1414 interface_file_declaration() { return s;}
1415 |
1416 LOOKAHEAD(subprogram_declaration())
1417 subprogram_declaration() { return s;}
1418 |
1419  s=object_class() s1=identifier()
1420  {
1421  if (parse_sec==GEN_SEC)
1422
1423     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,s1.data(),0,Public);
1424     return s;
1425     }
1426 }
1427
1428 QCString interface_element() :  {QCString s;}
1429 {
1430 s=interface_declaration(){ return s;}
1431 }
1432
1433 QCString interface_file_declaration() : {QCString s,s1;}
1434 {
1435 <FILE_T> s=identifier_list() <COLON_T> s1=subtype_indication()
1436 {
1437    addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public);
1438    return " file "+s+":"+s1;
1439 }
1440 }
1441
1442 QCString interface_list() :  {QCString s,s1,s2;}
1443 {
1444 s=interface_element() (LOOKAHEAD(1) <SEMI_T> s1=interface_element(){s2+=";";s2+=s1;})* { return s+s2;}
1445 }
1446
1447
1448
1449 QCString interface_variable_declaration() :  {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;}
1450 {
1451 [( tok=<VARIABLE_T> | tok=<SIGNAL_T> | tok=<CONSTANT_T>|tok=<SHARED_T>) ]
1452   s=identifier_list() <COLON_T> [ s1=mode() ]
1453   s2=subtype_indication()  [ tok1=<BUS_T> ] [ tok2=<VARASSIGN_T> s4=expression() ]
1454 {
1455                     if(tok)
1456                     s5=tok->image.c_str();
1457
1458                     if(tok1)
1459                      s3=tok1->image.data();
1460
1461                     if(tok2)
1462                      s3+=":=";
1463
1464                     QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4;
1465                     if (currP!=VhdlDocGen::COMPONENT)
1466                     {
1467                       if (currP==VhdlDocGen::FUNCTION || currP==VhdlDocGen::PROCEDURE)
1468                       {
1469                         addProto(s5.data(),s.data(),s1.data(),s2.data(),s3.data(),s4.data());
1470                       }
1471                       else
1472                       {
1473                         QCString i=s2+s3+s4;
1474                         if (currP==VhdlDocGen::GENERIC && param_sec==0)
1475                           addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
1476                         else if(parse_sec != GEN_SEC)
1477                           addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public);
1478                       }
1479                       //   fprintf(stderr,"\n\n <<port  %s  >>\n",$$.data());
1480                     } // if component
1481               return it;
1482             }
1483 }
1484
1485 QCString iteration_scheme() :  {QCString s;}
1486 {
1487 <WHILE_T> s=condition()
1488 {
1489    s.prepend("while ");
1490    FlowChart::addFlowChart(FlowChart::WHILE_NO,0,s.data(),lab.data());
1491    lab="";
1492   return s;
1493 }
1494 | <FOR_T> s=parameter_specification()
1495 {
1496     QCString q=lab+" for "+s;
1497     FlowChart::addFlowChart(FlowChart::FOR_NO,0,q.data(),lab.data());
1498     lab="";
1499     return q;
1500 }
1501 }
1502
1503 QCString label() :  {QCString s;}
1504 {
1505  s=identifier() { return s;}
1506 }
1507
1508 QCString library_clause() :  {QCString s;}
1509 {
1510  (<LIBRARY_T> s=identifier_list() <SEMI_T>
1511  )
1512  {
1513                if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
1514                    {
1515                            addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public);
1516                    }
1517                    QCString s1="library "+s;
1518                    return s1;
1519  }
1520 }
1521
1522 QCString library_unit() :  {QCString s;}
1523 {
1524 LOOKAHEAD(2)
1525 primary_unit() {  return s; }
1526 |  secondary_unit() {  return s; }
1527 |  context_declaration()
1528
1529 }
1530
1531 QCString literal() :  {QCString s;}
1532 {
1533
1534  LOOKAHEAD(bit_string_literal())
1535 s=bit_string_literal() { return s;}
1536 |
1537  LOOKAHEAD(numeric_literal())
1538  s=numeric_literal() { return s;}
1539 |
1540
1541 LOOKAHEAD(enumeration_literal())
1542 s=enumeration_literal() { return s;}
1543 | s=string_literal() { return s;}
1544 | <NULL_T> {return "null";}
1545 }
1546
1547 QCString logical_operator() :  {QCString s;}
1548 {
1549  s=logop() { return s;}
1550 }
1551
1552 QCString loop_statement() :  {QCString s,s1,s2,s3;}
1553 {
1554 [ s=identifier() <COLON_T> {s+=":";} ]
1555     [ s1=iteration_scheme()  ]
1556       {
1557        if(s1.isEmpty())
1558         FlowChart::addFlowChart(FlowChart::LOOP_NO,0,"infinite");
1559        }
1560       <LOOP_T>
1561         s2=sequence_of_statement()
1562         <END_T> <LOOP_T> [ s3=identifier() ] <SEMI_T>
1563         {
1564          QCString q = s+" loop "+s2+" end loop" +s3;
1565          QCString endLoop="end loop" + s3;
1566          FlowChart::moveToPrevLevel();
1567          FlowChart::addFlowChart(FlowChart::END_LOOP,endLoop.data(),0);
1568         return q;
1569         }
1570
1571 }
1572
1573
1574 QCString miscellaneous_operator():{Token *t=0;}
1575 {
1576   <DOUBLEMULT_T> {return "**";}
1577   | <ABS_T>  {return "abs";}
1578   | <NOT_T> {return "not";}
1579 }
1580
1581 QCString mode() :  {Token *tok=0;}
1582 {
1583 tok=<IN_T> { return "in"; }
1584 | tok=<OUT_T> { return "out"; }
1585 | tok=<INOUT_T> { return "inout"; }
1586 | tok=<BUFFER_T> { return "buffer"; }
1587 | tok=<LINKAGE_T> { return "linkage"; }
1588 }
1589
1590 QCString multiplying_operation() : {Token *tok=0;}
1591 {
1592 tok=<MULT_T>      { return tok->image.c_str(); }
1593 | tok=<SLASH_T>  { return tok->image.c_str(); }
1594 | tok=<MOD_T>     { return tok->image.c_str(); }
1595 | tok=<REM_T>     { return tok->image.c_str(); }
1596 }
1597
1598
1599  QCString name() :  {QCString s,s1;}
1600 {
1601  (
1602    s=operator_symbol()
1603    | s=identifier()| s=external_name()
1604   )
1605  [LOOKAHEAD(name_ext1()) s1=name_ext1(){ s+=s1;}] {  return s; }
1606 }
1607
1608 QCString name_ext1() : {QCString s,s1,s2;}
1609  {
1610    s=name_ext() (LOOKAHEAD(name_ext()) s1=name_ext(){s+=s1;})* { return s;}
1611  }
1612
1613  QCString name_ext() : {QCString s,s1,s2;}
1614  {
1615
1616   (
1617  LOOKAHEAD(<DOT_T> suffix())
1618  <DOT_T> s1=suffix(){s+=".";s+=s1;}
1619 |
1620   LOOKAHEAD(test_att_name())
1621    s1=test_att_name() { s+=s1;}
1622  |
1623  LOOKAHEAD( <LPAREN_T> discrete_range() <RPAREN_T>)
1624   <LPAREN_T> s1=discrete_range() <RPAREN_T> {s+="(";s+=s1;s+=")";}
1625    |
1626   LOOKAHEAD( "(" expression() ("," expression() )* ")" )
1627   <LPAREN_T> s1=expression() {s+="(";s+=s1;} (LOOKAHEAD(1) <COMMA_T>  s1=expression(){s+=",";s+=s1;})*  <RPAREN_T> { s+=")";}
1628
1629  )
1630  {return s;}
1631  }
1632
1633  QCString test_att_name() : {QCString s,s1;}
1634  {
1635   [ LOOKAHEAD(<LBRACKET_T>) s1=signature() {s=s1;}]
1636   <APOSTROPHE_T> s1=attribute_designator() {s+="'";s+=s1;}
1637   [LOOKAHEAD(1) <LPAREN_T> s1=expression() <RPAREN_T> {s+="(";s+=s1;s+=")";}]
1638    { return s;}
1639  }
1640
1641  QCString indexed_name() : {QCString s,s1,s2;}
1642  {
1643    s2=identifier() <LPAREN_T> s1=expression(){s=s2+"("+s1;} (<COMMA_T> s1=expression(){s+=",";s+=s1;})* <RPAREN_T> {return s+")";}
1644  }
1645
1646 QCString next_statement() :  {QCString s,s1,s2;Token *t=0;Token *t1=0;}
1647 {
1648 [LOOKAHEAD(1) s=identifier() t=<COLON_T> ] <NEXT_T> [ s1=identifier() ]
1649 [LOOKAHEAD(1)  t1=<WHEN_T> s2=condition() ] <SEMI_T>
1650 {
1651   if(t) s+=":";
1652    FlowChart::addFlowChart(FlowChart::NEXT_NO,"next ",s2.data(),s1.data());
1653     lab.resize(0);
1654   if(t1) s2.prepend("when ");
1655   return s+s1+s2+";";
1656 }
1657 }
1658
1659 QCString null_statement() : {QCString s;}
1660 {
1661 [ s=identifier() <COLON_T> {s+=":";}] <NULL_T> <SEMI_T>{return s+="null";}
1662 }
1663
1664 QCString numeric_literal() :  {QCString s;}
1665 {
1666
1667  LOOKAHEAD(physical_literal())
1668   s=physical_literal(){ return s;}
1669  | s=abstract_literal() { return s;}
1670 }
1671
1672 QCString object_class() :  {}
1673 {
1674 <CONSTANT_T>          { return "constant"; }
1675 |<SIGNAL_T>            { return "signal"; }
1676 |<VARIABLE_T>          { return "variable"; }
1677 |<SHARED_T> <VARIABLE_T> { return "shared variable"; }
1678 |<FILE_T>              { return "file"; }
1679 |<TYPE_T>              { return "type"; }
1680 }
1681
1682 QCString operator_symbol() :  {Token *tok=0;}
1683 {
1684 tok=<STRINGLITERAL> {return tok->image.c_str();}
1685 }
1686
1687 void options() :  {}
1688 {
1689   [ <GUARDED_T> ] [ delay_mechanism() ]
1690 }
1691
1692 void package_body() :  {QCString s;}
1693 {
1694 <PACKAGE_T> <BODY_T> s=name() <IS_T>
1695  {
1696                         lastCompound=current;
1697                         s.prepend("_");
1698                         addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected);
1699                       }
1700  package_body_declarative_part()
1701
1702 <END_T> [<PACKAGE_T> <BODY_T>  ] [ name() ] <SEMI_T> { lastCompound=0; genLabels.resize(0); }
1703 }
1704
1705 void package_body_declarative_item() :  {}
1706 {
1707 subprogram_declaration()
1708 //| subprogram_body()
1709 | type_declaration()
1710 | subtype_declaration()
1711 | constant_declaration()
1712 | variable_declaration()
1713 | file_declaration()
1714 | alias_declaration()
1715 | use_clause()
1716 |
1717 LOOKAHEAD(3)
1718 group_template_declaration()
1719 | group_declaration()
1720 }
1721
1722 void package_body_declarative_part() :  {}
1723 {
1724 (package_body_declarative_item() )*
1725 }
1726
1727 void package_declaration():  {QCString s;}
1728 {
1729
1730  <PACKAGE_T> s=identifier() <IS_T>
1731                           {
1732                           lastCompound=current;
1733                           Entry *clone=new Entry(*current);
1734                           clone->section=Entry::NAMESPACE_SEC;
1735                           clone->spec=VhdlDocGen::PACKAGE;
1736                           clone->name=s;
1737                           clone->startLine=getLine(PACKAGE_T);
1738                           clone->bodyLine=getLine(PACKAGE_T);
1739                           clone->protection=Package;
1740                           current_root->addSubEntry(clone);
1741                           addVhdlType(s,getLine(PACKAGE_T),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package);
1742                           }
1743     package_declarative_part()
1744 <END_T> [ <PACKAGE_T>] [ name() ] <SEMI_T>
1745 { lastEntity=0;lastCompound=0; genLabels.resize(0); }
1746 }
1747
1748 void geninter():{}
1749 {
1750     [gen_interface_list() <SEMI_T> [gen_assoc_list() <SEMI_T>]]
1751 }
1752
1753 void package_declarative_item() : {}
1754 {
1755 //LOOKAHEAD(3)
1756 //interface_subprogram_declaration()
1757 subprogram_declaration()
1758 | type_declaration()
1759 | subtype_declaration()
1760 | constant_declaration()
1761 | signal_declaration()
1762 | variable_declaration()
1763 | file_declaration()
1764 | alias_declaration()
1765 | component_declaration()
1766 |
1767 LOOKAHEAD(attribute_declaration())
1768  attribute_declaration()
1769 | attribute_specification()
1770 | disconnection_specification()
1771 | use_clause()
1772 |
1773 LOOKAHEAD(3)
1774  group_template_declaration()
1775 | group_declaration()
1776 |
1777  LOOKAHEAD(5)
1778  package_instantiation_declaration()
1779 |package_declaration()
1780
1781 }
1782
1783 void package_declarative_part() : {}
1784 {
1785  (package_declarative_item())*
1786 }
1787
1788 QCString parameter_specification() : {QCString s,s1;}
1789 {
1790 s=identifier() <IN_T> s1=discrete_range(){ return s+" in "+s1;}
1791 }
1792
1793 QCString physical_literal() :  {QCString s,s1;}
1794 {
1795  [LOOKAHEAD(abstract_literal()) s=abstract_literal()] s1=name(){s+=" ";s+=s1;s.prepend(" "); return s;}
1796 }
1797
1798 QCString physical_type_definition() : {QCString s,s1,s2;}
1799 {
1800         <UNITS_T>
1801             s=identifier()<SEMI_T> { addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,0,Public);}
1802             (
1803              s1=secondary_unit_declaration()
1804             )*
1805             <END_T> <UNITS_T>  [name()]
1806             { return s+"%";}
1807
1808 }
1809
1810 void port_clause() :  {}
1811 {
1812    <PORT_T> <LPAREN_T>  port_list()<RPAREN_T>  <SEMI_T>{ currP=0; }
1813 }
1814
1815 QCString port_list() : {QCString s;}
1816 {
1817   s=interface_list(){return s;}
1818 }
1819
1820 void port_map_aspect() : {}
1821 {
1822  <PORT_T> <MAP_T> <LPAREN_T> association_list() <RPAREN_T>
1823 }
1824
1825 QCString primary() : {QCString s,s1;}
1826 {
1827 LOOKAHEAD(function_call())
1828 s=function_call() { return s;}
1829 |
1830 LOOKAHEAD(<LPAREN_T> expression() <RPAREN_T>)
1831  <LPAREN_T> s1=expression() <RPAREN_T>{ s="("+s1+")"; return s;}
1832 |
1833 LOOKAHEAD(qualified_expression())
1834 s=qualified_expression() { return s;}
1835 |
1836 LOOKAHEAD(type_conversion())
1837 s=type_conversion() { return s;}
1838 |
1839 LOOKAHEAD(literal())
1840 s=literal() { s.prepend(" ");return s;}
1841 |
1842 LOOKAHEAD(name())
1843 s=name() { return s;}
1844 |
1845 allocator() { return "";}
1846 |
1847 s=aggregate() { return s; }
1848 }
1849
1850
1851 void primary_unit() : {}
1852 {
1853 entity_declaration()
1854 | configuration_declaration()
1855 |
1856 LOOKAHEAD(package_instantiation_declaration())
1857 package_instantiation_declaration()
1858 |
1859 LOOKAHEAD(4)
1860  interface_package_declaration()
1861 | package_declaration()
1862
1863 }
1864
1865 QCString procedure_call() : {QCString s,s1;}
1866 {
1867  s=name()  [ <LPAREN_T> s1=actual_parameter_part() <RPAREN_T>{ s1.prepend("("); s1.append(")");}]
1868 { return s+s1;}
1869  }
1870
1871 QCString procedure_call_statement() :  {QCString s,s1;}
1872 {
1873 [LOOKAHEAD(2) s=identifier() <COLON_T> { s+=":"; }] s1=procedure_call() <SEMI_T>
1874 {
1875   return s+s1+";";
1876 }
1877 }
1878
1879 QCString process_declarative_item() :  {QCString s;}
1880 {
1881 subprogram_declaration() { return "";}
1882 //| subprogram_body()
1883 | s=type_declaration() { return s;}
1884 | s=subtype_declaration() { return s;}
1885 | s=constant_declaration() { return s;}
1886 | s=variable_declaration() { return s;}
1887 | s=file_declaration() { return s;}
1888 | s=alias_declaration() { return s;}
1889 |
1890 LOOKAHEAD(3)
1891 s=attribute_declaration() { return s;}
1892 | s=attribute_specification() { return s;}
1893 | s=use_clause() { return s;}
1894 |
1895 LOOKAHEAD(3)
1896 s=group_template_declaration()  { return s;}
1897 | s=group_declaration() { return s;}
1898 }
1899
1900 QCString process_declarative_part() :{QCString s,s1;}
1901 {
1902  ( s1=process_declarative_item(){s+=s1;} )* { return s;}
1903 }
1904
1905 void process_statement() : {QCString s,s1,s2;Token *tok=0;}
1906 {
1907 [ s=identifier() <COLON_T> ]
1908 [ <POSTPONED_T> ]
1909  {
1910                currP=VhdlDocGen::PROCESS;
1911                current->startLine=getLine();
1912                current->bodyLine=getLine();
1913   }
1914  <PROCESS_T>
1915  //try{
1916  [ <LPAREN_T> (tok=<ALL_T> | s1=sensitivity_list()) <RPAREN_T> ] [ <IS_T> ]
1917         s2=process_declarative_part()
1918              {
1919               if (s2.data())
1920                   FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s2.data(),0);
1921                 FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0);
1922                }
1923         <BEGIN_T>
1924         process_statement_part()
1925         <END_T> [ <POSTPONED_T> ]
1926          // }catch(...){error_skipto(PROCESS_T);}
1927         <PROCESS_T> [ identifier() ] <SEMI_T>
1928  {
1929   if(s.isEmpty())
1930    currName=VhdlDocGen::getProcessNumber();
1931    else
1932    currName=s;
1933
1934    current->name=currName;
1935    tempEntry=current;
1936    current->endBodyLine=getLine();
1937    currP=0;
1938  if(tok)
1939    s1=tok->image.data();
1940   createFunction(currName,VhdlDocGen::PROCESS,s1.data());
1941   createFlow();
1942    currName="";
1943    newEntry();
1944 }
1945 }
1946
1947 void process_statement_part() :  {}
1948 {
1949   (sequential_statement())*
1950 }
1951
1952 QCString qualified_expression() :  {QCString s,s1;}
1953 {
1954   s1=identifier() <APOSTROPHE_T> {s=s1+"'";}
1955   (
1956     LOOKAHEAD(aggregate())
1957     s1=aggregate(){s+=s1;}
1958     | <LPAREN_T> s1=expression() <RPAREN_T>{s+="(";s+=s1;s+=")";}
1959  )
1960  {return s;}
1961 }
1962
1963 QCString range() :  {QCString s,s1,s2;}
1964 {
1965    LOOKAHEAD( simple_expression() direction() simple_expression())
1966    s=simple_expression() s1=direction() s2=simple_expression(){return s+" "+s1+" "+s2;}
1967   |
1968  LOOKAHEAD(attribute_name())
1969   s=attribute_name(){ return s;}
1970 }
1971
1972 QCString range_constraint() :  {QCString s,s1;}
1973 {
1974 <RANGE_T> s=range(){return " range "+s;}
1975 }
1976
1977 void record_type_definition() : {}
1978 {
1979     <RECORD_T>
1980      //  try{
1981        (element_declaration())+
1982             //    }catch(...){error_skipto(END_T);}
1983        <END_T>
1984        <RECORD_T> [ name()]
1985 }
1986
1987 QCString relation() :  {QCString s,s1,s2;}
1988 {
1989   s=shift_expression() [LOOKAHEAD(1) s1=relation_operator() s2=shift_expression() ] {return s+s1+s2;}
1990 }
1991
1992 QCString relation_operator() :  {}
1993 {
1994  <LT_T> {return "<";}
1995  |<GT_T> {return ">";}
1996  |<EQU_T> {return "=";}
1997  |<GREATERTHAN_T> {return ">=";}
1998  |<LESSTHAN_T> {return "<=";}
1999  |<NOTEQU_T> {return "/=";}
2000
2001 }
2002
2003 QCString report_statement() :  {Token *t=0;Token *t1=0;QCString s,s1,s2;}
2004 {
2005 [ s=identifier() t=<COLON_T> ]
2006     <REPORT_T> s1=expression()
2007         [ t1=<SEVERITY_T> s2=expression() ] <SEMI_T>
2008         {
2009         if(t) s.append(":");
2010         s1.prepend(" report ");
2011         if(t1) s2.prepend(" severity ");
2012         return s+s1+s2+";";
2013         }
2014 }
2015
2016 QCString return_statement() :  {QCString s,s1;}
2017 {
2018 [ s=identifier() <COLON_T> { s+=":";}] <RETURN_T> [ s1=expression() ] <SEMI_T>
2019 { return s+" return "+s1+";";}
2020 }
2021
2022 QCString scalar_type_definition() : {QCString s,s1;}
2023 {
2024
2025 s=enumeration_type_definition(){ return s;}
2026 | s=range_constraint() [LOOKAHEAD( physical_type_definition()) s1=physical_type_definition()] { return s+" "+s1+"%";}
2027 }
2028
2029 void secondary_unit() :  {}
2030 {
2031 architecture_body()
2032 | package_body()
2033 }
2034
2035 QCString secondary_unit_declaration() :  {QCString s,s1;}
2036 {
2037 s=identifier() <EQU_T> s1=physical_literal() <SEMI_T>
2038 {
2039   //printf("\n %s %s [%d]",s.data(),s1.data(),getLine());
2040   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::UNITS,0,s1.data(),Public);
2041
2042   return s+"="+s1; }
2043 }
2044
2045 QCString selected_name() : {QCString s,s1;}
2046 {
2047  s=identifier() <DOT_T> s1=suffix(){ return s+"."+s1;}
2048 }
2049
2050 void selected_signal_assignment() :  {}
2051 {
2052   <WITH_T> expression() <SELECT_T>
2053
2054     target() < LESSTHAN_T> options() selected_waveforms() <SEMI_T>
2055 }
2056
2057 void selected_waveforms() :  {}
2058 {
2059  waveform() <WHEN_T> choices()(<COMMA_T> waveform() <WHEN_T> choices())*
2060 }
2061
2062 QCString sensitivity_clause() :  {QCString s;}
2063 {
2064  <ON_T> s=sensitivity_list()
2065  {
2066   s.prepend(" on ");
2067   return s;
2068   }
2069 }
2070
2071 QCString sensitivity_list() :  {QCString s,s1;}
2072 {
2073  s=name() (<COMMA_T> s1=name(){s+=",";s+=s1;} )* { return s;}
2074 }
2075
2076 QCString sequence_of_statement() : {QCString s,s1;}
2077 {
2078  ( LOOKAHEAD(3) s1=sequential_statement() {s+=s1;} )* { return s;}
2079 }
2080
2081 QCString sequential_statement() :{QCString s;}
2082 {
2083     LOOKAHEAD( [ identifier() ":" ] target() "<=")
2084     s=signal_assignment_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2085     |
2086     LOOKAHEAD(3)
2087     s=assertion_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2088     |
2089      LOOKAHEAD(3)
2090     s=report_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2091     |
2092     LOOKAHEAD(3)
2093     s=wait_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2094     |
2095     LOOKAHEAD(  [ identifier() ":" ] target() ":=" )
2096     s=variable_assignment_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2097     |
2098     LOOKAHEAD(3)
2099     s=procedure_call_statement(){ FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s; }
2100     |
2101      LOOKAHEAD(3)
2102     if_statement(){return s;}
2103     |
2104      LOOKAHEAD(3)
2105     case_statement(){return s;}
2106     |
2107     LOOKAHEAD(3)
2108     loop_statement(){return s;}
2109     |
2110     LOOKAHEAD(3)
2111     s=next_statement() {return s;}
2112     |
2113     LOOKAHEAD(3)
2114     s=exit_statement(){return s;}
2115     |
2116     LOOKAHEAD(3)
2117     s=return_statement(){FlowChart::addFlowChart(FlowChart::RETURN_NO,s.data(),0);return s;}
2118     |
2119     s=null_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);return s;}
2120 }
2121
2122 QCString shift_expression() :  {QCString s,s1,s2;}
2123 {
2124  s=simple_expression() [ s1=shift_operator() s2=simple_expression() ] { return s+s1+s2;}
2125 }
2126 QCString shift_operator() :  {}
2127 {
2128   <SLL_T> { return "sll";}
2129   | <SRL_T> { return "srl";}
2130   | <SLA_T> { return "sla";}
2131   | <SRA_T> { return "sra";}
2132   | <ROL_T> { return "rol";}
2133   | <ROR_T> { return "ror";}
2134 }
2135
2136 QCString sign() :  {}
2137 {
2138  <PLUS_T> { return "+";}
2139  | <MINUS_T> { return "-";}
2140 }
2141
2142 QCString signal_assignment_statement() : {QCString s,s1,s2,s3;}
2143 {
2144
2145   LOOKAHEAD(conditional_signal_assignment_wave())
2146   conditional_signal_assignment_wave(){ return ""; }
2147 |
2148   LOOKAHEAD(selected_signal_assignment_wave())
2149   selected_signal_assignment_wave() { return ""; }
2150   |
2151   [LOOKAHEAD(2) s=identifier() <COLON_T> {s+=":";} ]
2152 s1=target() <LESSTHAN_T>
2153 [ s2=delay_mechanism() ]
2154 s3=waveform() <SEMI_T>
2155 {
2156   return s+s1+"<="+s2+s3+";";
2157 }
2158
2159 }
2160
2161 void semi() :  {}
2162 {
2163 <SEMI_T>
2164 }
2165
2166 void signal_declaration() :  { Token* tok=0;QCString s,s1,s2,s3,s4;}
2167 {
2168 <SIGNAL_T> s=identifier_list() <COLON_T> s1=subtype_indication() [ s2=signal_kind() ] [ tok=<VARASSIGN_T> s3=expression() ] <SEMI_T>
2169      {
2170      if(tok)
2171       s3.prepend(":=");
2172      s4=s1+s2+s3;
2173      addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public);
2174      }
2175 }
2176 QCString signal_kind() :  {}
2177 {
2178   <REGISTER_T> { return "register";}
2179   | <BUS_T>  { return "bus";}
2180 }
2181
2182 QCString signal_list() : {QCString s,s1;}
2183 {
2184  s=name() (<COMMA_T>  s1=name() { s+=",";s+=s1;})*
2185 | <OTHER_T> { return "other";}
2186 | <ALL_T> { return "all";}
2187 }
2188
2189 QCString signature() : {QCString s,s1,s2;}
2190 {
2191 <LBRACKET_T>
2192  [ s=name()  (<COMMA_T> s1=name() {s+=",";s+=s1; })* ]
2193  [ <RETURN_T> s1=name() {s+="return ";s+=s1;}]
2194   <RBRACKET_T>
2195   { s1="["+s+"]";return s1;}
2196  }
2197
2198 QCString simple_expression():  {QCString s,s1,s2;}
2199 {
2200 [ s=sign() ] s1=term() {s+=s1;} ( LOOKAHEAD(adding_operator() term()) s1=adding_operator() s2=term() {s+=s1;s+=s2;})* { return s;}
2201 }
2202
2203 void simple_name() :  {}
2204 {
2205 name()
2206 }
2207
2208 QCString slice_name() :  {QCString s,s1;}
2209 {
2210  s=identifier() <LPAREN_T> s1=discrete_range() <RPAREN_T> {return s+"("+s1+")";}
2211 }
2212
2213 QCString string_literal() : {Token *tok=0;}
2214 {
2215 tok=<STRINGLITERAL> {return tok->image.c_str();}
2216 }
2217
2218  void subprogram_body() : {QCString s;}
2219 {
2220 //subprogram_specification()
2221 <IS_T>
2222  //try{
2223  s=subprogram_declarative_part()
2224    {
2225       if (s.data())
2226       {
2227         FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s,0);
2228       }
2229       FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0);
2230     }
2231  // }catch(...){error_skipto(BEGIN_T);}
2232 <BEGIN_T>
2233 subprogram_statement_part()
2234 <END_T> [ subprogram_kind() ] [ designator() ] <SEMI_T>
2235  {
2236       tempEntry->endBodyLine=getLine(END_T);
2237       createFlow();
2238       currP=0;
2239     }
2240 }
2241
2242 void subprogram_declaration() :  {}
2243 {
2244 LOOKAHEAD(subprogram_instantiation_declaration())
2245 subprogram_instantiation_declaration()
2246 |
2247 subprogram_specification()subprogram_1(){currP=0;}
2248 }
2249
2250 void subprogram_1() :  {}
2251 {
2252
2253  subprogram_body()
2254  | <SEMI_T>
2255 }
2256
2257 QCString subprogram_declarative_item() : {QCString s;}
2258 {
2259 subprogram_declaration(){ return "";}
2260 |s=type_declaration(){ return s;}
2261  | subprogram_body(){ return "";}
2262 | s=subtype_declaration(){ return s;}
2263 | s=constant_declaration(){ return s;}
2264 | s=variable_declaration(){ return s;}
2265 | s=file_declaration(){ return s;}
2266 | s=alias_declaration(){ return s;}
2267 |
2268 LOOKAHEAD(attribute_declaration())
2269 s=attribute_declaration(){ return s;}
2270 | s=attribute_specification(){ return s;}
2271 | s=use_clause(){ return s;}
2272 |
2273 LOOKAHEAD(3)
2274 s=group_template_declaration(){ return s;}
2275 | s=group_declaration() { return s;}
2276 }
2277
2278 QCString subprogram_declarative_part() : {QCString s,s1;}
2279 {
2280   (s1=subprogram_declarative_item(){s+=s1;})* { return s;}
2281 }
2282
2283 void subprogram_kind() :  {}
2284 {
2285  <FUNCTION_T>
2286  |<PROCEDURE_T>
2287 }
2288
2289 void subprogram_specification() : {QCString s;Token *tok=0;Token *t;}
2290 {
2291  <PROCEDURE_T> s=designator()
2292  {
2293               currP=VhdlDocGen::PROCEDURE;
2294               createFunction(s.data(),currP,0);
2295               tempEntry=current;
2296                current->startLine=getLine(PROCEDURE_T);
2297                current->bodyLine=getLine(PROCEDURE_T);
2298
2299               } [LOOKAHEAD(1) <LPAREN_T> { param_sec=PARAM_SEC; } interface_list() { param_sec=0; }<RPAREN_T> ]
2300              [LOOKAHEAD(2) gen_interface_list()]
2301              [ LOOKAHEAD(2) gen_assoc_list()]
2302              param()
2303               {  newEntry(); }
2304 |
2305  [ (tok=<PURE_T> | tok=<IMPURE_T>) ] t=<FUNCTION_T> s=designator()
2306   {
2307      currP=VhdlDocGen::FUNCTION;
2308      if(tok)
2309      createFunction(tok->image.c_str(),currP,s.data());
2310      else
2311      createFunction(0,currP,s.data());
2312       tempEntry=current;
2313       current->startLine=getLine(FUNCTION_T);
2314       current->bodyLine=getLine(FUNCTION_T);
2315   }
2316  [{ param_sec=PARAM_SEC; } <LPAREN_T> formal_parameter_list() <RPAREN_T> { param_sec=0; }]
2317     <RETURN_T> s=type_mark()
2318              {
2319                 tempEntry=current;
2320                 current->type=s;
2321                 newEntry();
2322               }
2323 }
2324
2325 void subprogram_statement_part() : {}
2326 {
2327   (sequential_statement())*
2328 }
2329
2330 QCString subtype_declaration() :  {QCString s,s1;}
2331 {
2332 <SUBTYPE_T> s=identifier() <IS_T> s1=subtype_indication() <SEMI_T>
2333   {
2334   addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public);
2335   return " subtype "+s+" is "+s1+";";
2336   }
2337 }
2338
2339 QCString subtype_indication() :  {QCString s,s1,s2;}
2340 {
2341  s=name()
2342  [LOOKAHEAD (name()) s1=name()] [LOOKAHEAD(constraint() ) s2=constraint()]
2343  {return s+" "+s1+" "+s2;}
2344 }
2345
2346 QCString suffix() :  {QCString s;}
2347 {
2348 LOOKAHEAD(name())
2349 s=name() { return s;}
2350 | s=character_literal() { return s;}
2351 | s=operator_symbol(){ return s;}
2352 | <ALL_T> {return " all ";}
2353 }
2354
2355 QCString target() :  {QCString s;}
2356 {
2357  s=name(){ return s;}
2358 | s=aggregate() { return s;}
2359 }
2360
2361 QCString term() : {QCString s,s1,s2;}
2362 {
2363  s=factor() ( LOOKAHEAD(2) s1=multiplying_operation() s2=factor(){s+=s1;s+=s2;} )* { return s;}
2364 }
2365
2366 QCString timeout_clause() : {QCString s;}
2367 {
2368 <FOR_T>  s=expression()
2369 {
2370   return " for "+s;
2371 }
2372 }
2373
2374 QCString type_conversion() : {QCString s,s1;}
2375 {
2376   s=name() <LPAREN_T> s1=expression() <RPAREN_T> { return s+"("+s1+")";}
2377 }
2378
2379 QCString type_declaration() : {QCString s;}
2380 {
2381 LOOKAHEAD(3)
2382 s=full_type_declaration(){ return s;}
2383 | s=incomplete_type_declaration(){ return s;}
2384 }
2385
2386 QCString type_definition() :  {QCString s;}
2387 {
2388 //try{
2389 s=scalar_type_definition(){ return s;}
2390 | s=composite_type_definition(){ return s;}
2391 | s=access_type_definition(){ return s;}
2392 | s=file_type_definition(){ return s;}
2393 |
2394  LOOKAHEAD(2)
2395  protected_type_body()            { return ""; }
2396 | protected_type_declaration()     { return ""; }
2397 //}catch(...){error_skipto(SEMI_T); return "";}
2398 }
2399
2400 QCString type_mark() : {QCString s; }
2401 {
2402   s=name() { return s;}
2403 }
2404
2405 QCString unconstraint_array_definition() :  {QCString s,s1,s2,s3;}
2406 {
2407 <ARRAY_T> <LPAREN_T> s=index_subtype_definition() ( <COMMA_T> s1=index_subtype_definition(){s3+=",";s3+=s1;})* <RPAREN_T>
2408  <OF_T> s2=subtype_indication() {return "array("+s+s3+") of "+s2;}
2409 }
2410
2411  QCString use_clause() :  {QCString s,s1;}
2412 {
2413  <USE_T> s=selected_name()(<COMMA_T> s1=selected_name(){s+=",";s+=s1;})*   <SEMI_T>
2414   {
2415                    QCStringList ql1=QCStringList::split(",",s);
2416                    for (uint j=0;j<ql1.count();j++)
2417                    {
2418                      QCStringList ql=QCStringList::split(".",ql1[j]);
2419                      QCString it=ql[1];
2420                      if ( parse_sec==0 && Config_getBool(SHOW_INCLUDE_FILES) )
2421                      {
2422                        VhdlParser::addVhdlType(it.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public);
2423                      }
2424                    }
2425                    s1="use "+s;
2426                    return s1;
2427    }
2428 }
2429
2430 QCString variable_assignment_statement() :  {QCString s,s1,s2;}
2431 {
2432 [LOOKAHEAD(2) s=identifier() <COLON_T> {s+=":";}]
2433  s1=target() <VARASSIGN_T> s2=expression() <SEMI_T>
2434  {return s+s1+":="+s2+";";}
2435  |
2436  selected_variable_assignment() { return "";  }
2437 }
2438
2439 QCString variable_declaration() :  {Token *tok=0;Token *t1=0;QCString s,s1,s2;}
2440 {
2441 [ tok=<SHARED_T> ] <VARIABLE_T> s=identifier_list() <COLON_T> s1=subtype_indication()
2442 [ t1=<VARASSIGN_T> s2=expression() ] <SEMI_T>
2443
2444 {
2445     int spec;
2446     if(t1)
2447      s2.prepend(":=");
2448     QCString val=" variable "+s+":"+s1+s2+";";
2449     QCString it=s1;
2450     if(tok != 0)
2451     {
2452      it.prepend(" shared ");
2453      val.prepend(" shared");
2454      spec=VhdlDocGen::SHAREDVARIABLE;
2455      }
2456      else
2457      spec=VhdlDocGen::SHAREDVARIABLE;
2458
2459     if(t1){
2460      it+=":=";
2461      it+=s2;
2462      }
2463     addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public);
2464     return val;
2465  }
2466
2467 }
2468
2469 QCString wait_statement() :  {QCString s,s1,s2,s3;Token *t=0;}
2470 {
2471 [ s=identifier() t=<COLON_T> ] <WAIT_T> [ s1=sensitivity_clause() ] [ s2=condition_clause() ] [ s3=timeout_clause() ] <SEMI_T>
2472 {
2473   if(t) s.append(":");
2474   return s+" wait "+s1+s2+s3+";";
2475 }
2476 }
2477
2478 QCString waveform() :  {QCString s,s1;}
2479 {
2480 s=waveform_element() (LOOKAHEAD(1) <COMMA_T> s1=waveform_element(){s+=","; s+=s1;})* { return s;}
2481 |
2482 <UNAFFECTED_T> { return " unaffected ";}
2483
2484 }
2485
2486 QCString waveform_element() :  {QCString s,s1;}
2487 {
2488  s=expression() [ <AFTER_T> s1=expression(){ s1.prepend(" after ");} ]
2489  { return s+s1;}
2490 //<NULL_T> [ <AFTER_T> expression() ]
2491 }
2492
2493 // -----------------------------------------------------------------
2494 // VHDL 2002
2495 // -----------------------------------------------------------------
2496
2497 QCString protected_type_body() :{ }
2498 {
2499   // try{
2500    <PROTECTED_T> <BODY_T>
2501           protected_type_body_declarative_part()
2502
2503     //}catch(...){error_skipto(END_T);}
2504     <END_T><PROTECTED_T> <BODY_T>   [identifier()]  {return "";}
2505 }
2506
2507 void protected_type_body_declarative_item() :    { }
2508  {
2509     subprogram_declaration()
2510     | subprogram_body()
2511     | type_declaration()
2512     | subtype_declaration()
2513     | constant_declaration()
2514     | variable_declaration()
2515     | file_declaration()
2516     | alias_declaration()
2517     |
2518       LOOKAHEAD( attribute_declaration())
2519       attribute_declaration()
2520     | attribute_specification()
2521     | use_clause()
2522     | LOOKAHEAD(3)
2523       group_template_declaration()
2524     | group_declaration()
2525
2526 }
2527
2528 void protected_type_body_declarative_part() :{  }
2529 {
2530     ( protected_type_body_declarative_item ())*
2531 }
2532
2533
2534 QCString protected_type_declaration() : {  }
2535  {
2536    <PROTECTED_T>
2537         try{
2538           protected_type_declarative_part()
2539         }catch(...){error_skipto(END_T);}
2540        <END_T><PROTECTED_T> [ identifier() ] { return "";}
2541  }
2542
2543
2544 void protected_type_declarative_item():    { }
2545 {
2546     subprogram_specification()
2547     | attribute_specification()
2548     | use_clause()
2549 }
2550
2551 void protected_type_declarative_part() :    {}
2552 {
2553     (protected_type_declarative_item ()<SEMI_T>)*
2554 }
2555
2556 // -----------------------------------------------------------------
2557 // VHDL 2008
2558 // -----------------------------------------------------------------
2559
2560 QCString context_ref() : {QCString s;}
2561 {
2562  <CONTEXT_T>  s=identifier_list() <SEMI_T>
2563  {
2564   return "context "+s ;
2565  }
2566 }
2567
2568 void context_declaration(): {QCString s,s1;}
2569 {
2570  <CONTEXT_T> s=identifier() <IS_T> { parse_sec=CONTEXT_SEC; }  (s1=libustcont_stats())* <END_T> [ <CONTEXT_T> ][identifier()] <SEMI_T>
2571                         {
2572                           parse_sec=0;
2573                           addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public);
2574                         }
2575 }
2576
2577 QCString libustcont_stats(): {QCString s;}
2578 {
2579    s=use_clause()  { return s;}
2580    | s=library_clause() { return s;}
2581    | s=context_ref() { return s;}
2582 }
2583
2584  void package_instantiation_declaration() : {QCString s,s1,s2;}
2585  {
2586  <PACKAGE_T> s=identifier() <IS_T>  <NEW_T> s1=name() s2=signature() [gen_assoc_list()] <SEMI_T>
2587     {
2588       QCString q=" is new "+s1+s2;
2589       addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public);
2590     }
2591 }
2592
2593 QCString interface_package_declaration(): {QCString s,s1;}
2594 {
2595  <PACKAGE_T> s=identifier() <IS_T> <NEW_T> s1=name() [gen_assoc_list()]
2596                         {
2597                           current->name=s;
2598                             return "package "+s+" is new "+s1;
2599                          }
2600 }
2601
2602 QCString subprogram_instantiation_declaration():{QCString s,s1,s2;}
2603 {
2604  <FUNCTION_T>  s=identifier() <IS_T> <NEW_T> s1=name()  s2=signature() [gen_assoc_list()] <SEMI_T>
2605     {
2606      QCString q= " is new "+s1+s2;
2607       addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public);
2608     return q;
2609     }
2610 }
2611
2612
2613 void gen_assoc_list():{}
2614 {
2615    <GENERIC_T> <MAP_T> <LPAREN_T>  association_list()<RPAREN_T>
2616 }
2617
2618 void gen_interface_list() : {}
2619 {
2620    <GENERIC_T><LPAREN_T>
2621                         {
2622                           //int u=s_str.iLine;
2623                           parse_sec=GEN_SEC;
2624                         }
2625                         interface_list()
2626                         {
2627                         //  QCString vo=$3;
2628                           parse_sec=0;
2629                         }
2630                         <RPAREN_T>
2631 }
2632
2633 void case_scheme (): {}
2634 {
2635  <CASE_T> expression() <GENERATE_T> when_stats() [LOOKAHEAD(3) ttend()]  <END_T>
2636  <GENERATE_T> generate_statement_body() <SEMI_T>
2637 }
2638
2639 void when_stats() : {}
2640 {
2641   (
2642    <WHEN_T> [LOOKAHEAD(2) label() <COLON_T>] choices() <ARROW_T> generate_statement_body()
2643    )+
2644 }
2645
2646 void ttend(): {}
2647 {
2648   <END_T> [identifier()] <SEMI_T>
2649  }
2650
2651
2652 void generate_statement_body() : {}
2653 {
2654    <BEGIN_T> generate_statement_body()
2655 }
2656
2657 void generate_statement_body1() : {}
2658 {
2659   //   [LOOKAHEAD(block_declarative_item()<BEGIN_T> )(block_declarative_item() )*  <BEGIN_T>] (concurrent_statement())*
2660
2661    [(LOOKAHEAD(block_declarative_item())block_declarative_item() )*  <BEGIN_T>] (concurrent_statement())*
2662   // | (concurrent_statement())*
2663 }
2664
2665 QCString external_name(): {QCString s,s1,s2;}
2666 {
2667  <SLSL_T> s=sig_stat() s1=external_pathname() <COLON_T>  s2=subtype_indication()  <RSRS_T>
2668                         {
2669                          QCString t="<<"+s;
2670                          QCString t1=s1+":"+s2+">>";
2671                          return   s+s1;
2672                         }
2673 }
2674
2675 QCString sig_stat(): {Token *t;}
2676 {
2677   t=<CONSTANT_T>      { return t->image.data(); }
2678   | t=<SIGNAL_T>      { return t->image.data(); }
2679   | t=<VARIABLE_T>   { return t->image.data(); }
2680
2681 }
2682
2683 QCString external_pathname(): {QCString s;}
2684 {
2685    s=absolute_pathname()  { return s;}
2686  | s=relative_pathname()   { return s;}
2687  | s=package_path_name()   { return s;}
2688  }
2689
2690 QCString absolute_pathname(): {QCString s,s1;}
2691 {
2692  LOOKAHEAD(<DOT_T>  pathname_element_list())
2693  <DOT_T>  s=pathname_element_list() s1=identifier() { return "."+s+s1;}
2694 | <DOT_T>  s=identifier (){ return "."+s;}
2695 }
2696
2697 QCString relative_pathname():{QCString s,s1,s2;}
2698 {
2699   s=neg_list() [LOOKAHEAD( pathname_element_list()) s1=pathname_element_list() ] s2=identifier() { return s+s1+s2;}
2700 }
2701
2702 QCString neg_list(): {QCString s;}
2703 {
2704  (<NEG_T> <DOT_T>{s+="^.";})+     {return s; }
2705 }
2706
2707 QCString pathname_element ():{QCString s,s1;}
2708 {
2709   s=identifier() [<LPAREN_T> s1=expression()  <RPAREN_T>]
2710   {
2711     if(!s1.isEmpty())
2712      return s+"("+s1+")";
2713
2714     return s;
2715   }
2716  }
2717
2718 QCString pathname_element_list():{QCString s,s1,s2;}
2719 {
2720         ( s=pathname_element() <DOT_T> ) {s+=".";} (LOOKAHEAD(pathname_element() <DOT_T>) s1=pathname_element() <DOT_T> {s2+=s1;s2+="."; })*
2721         { return s+s2; }
2722 }
2723
2724 QCString package_path_name():{QCString s;}
2725 {
2726  <AT_T> s=name() { return "@"+s; }
2727 }
2728
2729 void conditional_signal_assignment_wave(): {}
2730 {
2731   LOOKAHEAD(conditional_force_assignment())
2732   conditional_force_assignment()
2733   |conditional_waveform_assignment()
2734 }
2735
2736 void conditional_waveform_assignment():{}
2737 {
2738  target() <LESSTHAN_T> [LOOKAHEAD(1) delay_mechanism() ] waveform_element() <WHEN_T> expression() [else_wave_list()] <SEMI_T>
2739  }
2740
2741 void  else_wave_list(): {}
2742 {
2743 <ELSE_T> expression() [ <WHEN_T> expression()]
2744 }
2745
2746 void conditional_force_assignment(): {}
2747 {
2748  target()  <LESSTHAN_T> <FORCE_T>  [inout_stat()] expression() <WHEN_T> [expression() else_stat()] <SEMI_T>
2749 }
2750
2751 void selected_signal_assignment_wave() : {}
2752 {
2753  LOOKAHEAD(selected_force_assignment() )
2754  selected_force_assignment()
2755 | selected_waveform_assignment()
2756 }
2757
2758 void selected_variable_assignment():{}
2759 {
2760   <WITH_T> expression() <SELECT_T> [<Q_T>] select_name() <VARASSIGN_T> sel_var_list() // { $$=""; }
2761 }
2762
2763 void select_name(): {}
2764 {
2765  LOOKAHEAD(aggregate())
2766  aggregate()
2767   | name()
2768
2769 }
2770
2771 void selected_waveform_assignment():{}
2772 {
2773  <WITH_T> expression() <SELECT_T>  [<Q_T>]
2774    target() <LESSTHAN_T> [delay_mechanism()] sel_wave_list()
2775 }
2776
2777 void selected_force_assignment():{}
2778 {
2779 <WITH_T> expression() <SELECT_T> [<Q_T>] target() <LESSTHAN_T> <FORCE_T>
2780                                                   [inout_stat()] sel_var_list()
2781 }
2782
2783 void sel_var_list(): {}
2784 {
2785   (expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))(LOOKAHEAD(expression() <WHEN_T>) expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))*
2786
2787 }
2788
2789
2790 void sel_wave_list() : {}
2791 {
2792    waveform_element() <WHEN_T> choices() (LOOKAHEAD(1) <COMMA_T> sel_wave_list())* <SEMI_T>
2793   // |  sel_wave_list_1()
2794 }
2795
2796 void inout_stat(): {}
2797 {
2798   <IN_T>
2799  | <OUT_T>
2800  }
2801
2802 void else_stat(): {}
2803 {
2804    (<ELSE_T> expression() [LOOKAHEAD(1) <WHEN_T> expression()])+
2805 }
2806
2807
2808
2809 QCString interface_subprogram_declaration(): {QCString s;}
2810 {
2811   s=iproc()  { return s;}
2812  | s=ifunc()  { return s; }
2813 }
2814
2815 QCString iproc(): {QCString s,s1;}
2816  {
2817   <PROCEDURE_T> s=identifier()  s1=param()
2818   {
2819   current->name=s;
2820   return "procedure "+s+s1;
2821   }
2822  }
2823
2824 QCString ifunc():{QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;}
2825 {
2826
2827  [t=<PURE_T> | t=<IMPURE_T> ] <FUNCTION_T>  s=name() s1=param() <RETURN_T> s2=name() [t1=<IS_T> (s3=identifier() | t2=<BOX_T>)]
2828     {
2829       QCString q;
2830       if(t) q=t->image.data();
2831       if(t2) s3="<>";
2832       if (!s3.isEmpty())
2833       {
2834         s3.prepend(" is ");
2835       }
2836      current->name=s;
2837     if (parse_sec==GEN_SEC)
2838                     {
2839                       QCString ss=q+" function "+s1+" return "+s2+s3;
2840                       int a=getLine(FUNCTION_T);
2841                       int b=getLine(PROCEDURE_T);
2842
2843                       if (a>b) b=a;
2844                       addVhdlType(current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public);
2845                     }
2846          currP=0;return "";
2847        }
2848
2849     }
2850
2851
2852 QCString param(): {QCString s,s1;Token *tok=0;}
2853 {
2854 [ tok=<PARAMETER_T> ] { param_sec=PARAM_SEC; }
2855                   [ <LPAREN_T>  s1=interface_list() <RPAREN_T>]
2856                    {
2857                        if(tok)
2858                      {
2859                       s = tok->image.data();
2860
2861                     }
2862                       param_sec=0;
2863                       return s+"("+s1+")";
2864                     }
2865
2866  }
2867
2868  // -----------------------------------------------------------------
2869  // needed for inline (function/process/procedure) parsing
2870
2871 void parseInline() :  {}
2872 {
2873  process_statement()
2874  | subprogram_declaration()
2875  }