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