diff options
Diffstat (limited to 'vhdlparser/vhdlparser.jj')
| -rw-r--r-- | vhdlparser/vhdlparser.jj | 2758 |
1 files changed, 2758 insertions, 0 deletions
diff --git a/vhdlparser/vhdlparser.jj b/vhdlparser/vhdlparser.jj new file mode 100644 index 0000000..daeceed --- /dev/null +++ b/vhdlparser/vhdlparser.jj @@ -0,0 +1,2758 @@ +/****************************************************************************** + * + * Copyright (C) 2014 by M. Kreis + * + * Permission to use, copy, modify, and distribute this software and its + * documentation under the terms of the GNU General Public License is hereby + * granted. No representations are made about the suitability of this software + * for any purpose. It is provided "as is" without express or implied warranty. + * See the GNU General Public License for more details. + * + */ +options { + JAVA_UNICODE_ESCAPE = true; + OUTPUT_LANGUAGE = "c++"; + NAMESPACE = "vhdl::parser"; + STATIC=false; + PARSER_INCLUDES="VhdlParser.h"; + TOKEN_MANAGER_INCLUDES="VhdlParser.h"; + + //OUTPUT_DIRECTORY = "."; + //DEBUG_PARSER=true; + //DEBUG_LOOKAHEAD=true; + + } + +PARSER_BEGIN(VhdlParser) + +typedef unsigned long long uint64; + + +static Entry* current_root; +static Entry* tempEntry; +static Entry* lastEntity ; +static Entry* lastCompound ; +static Entry* current; +static QCString compSpec; +static QCString currName; +static int levelCounter; +static QCString confName; +static QCString genLabels; +static QCString lab; +static QCString forL; +static int param_sec ; +static int parse_sec; +static int currP; +static Entry* currentCompound; + +//---------------------------------------- + +static void setLineParsed(int tok); +static int getLine(int tok); +static int getLine(); +static void lineCount(const char*); +static void lineCount(); +static void addProto(const char *s1,const char *s2,const char *s3,const char *s4,const char *s5,const char *s6); +static void addConfigureNode(const char* a,const char*b, bool,bool isLeaf,bool inlineConf); +static void createFunction(const char *impure,uint64 spec,const char *fname); +static void addVhdlType(const char *n,int startLine,int section, uint64 spec,const char* args,const char* type,Protection prot); +static void addCompInst(char *n, char* instName, char* comp,int iLine); +static void handleCommentBlock(const char* doc,bool brief); +static void initEntry(Entry *e); +static void newEntry(); +static bool isFuncProcProced(); +static void pushLabel(QCString &,QCString&); +static QCString popLabel(QCString & q); +static bool addLibUseClause(const QCString &type); +static void mapLibPackage( Entry* root); +static void createFlow(); +static void error_skipto(int kind); + +PARSER_END(VhdlParser) + +SKIP : +{ + " " +| "\t" +| "\n" {::vhdl::parser::VhdlParser::lineCount();} +| "\r" +} + +MORE : +{ + // VHDL comment -- ...... + // VHDL doxygen comment --! .... + <#DOXYGEN_VHDL_COMMENT: "--!" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?> + | <MULT_DOXYGEN_COMMENT: (<DOXYGEN_VHDL_COMMENT>)+ > {::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),TRUE);image.clear();} + | <VHDL_COMMENT: "--" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?> { ::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();} +} + +// VHDL 2008 comment /* .... */ +// VHDL 2008 doxygen comment /*! .... */ +MORE : +{ + <MULT_DOXYGEN_VHDL_COMMENT_2008 : "/*!" (~[])* "*/" > {::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),TRUE);image.clear();} + | <MULT_VHDL_2008_COMMENT : "/*" (~[])* "*/" > {::vhdl::parser::VhdlParser::lineCount(image.data());image.clear();} +} + +/* KEYWORDS */ + +TOKEN [IGNORE_CASE] : +{ + <ABS_T: "abs"> +| <ACCESS_T: "access"> +| <AFTER_T: "after"> +| <ALIAS_T: "alias"> +| <ALL_T: "all"> +| <AND_T: "and"> +| <ARCHITECTURE_T: "architecture"> {::vhdl::parser::VhdlParser::setLineParsed(ARCHITECTURE_T);} +| <ARRAY_T: "array"> {::vhdl::parser::VhdlParser::setLineParsed(ARRAY_T);} +| <ASSERT_T: "assert"> +| <ASSUME_T: "assume"> +| <ASSUME_GUARANTEE_T: "assume_guarentee"> +| <ATTRIBUTE_T: "attribute"> {::vhdl::parser::VhdlParser::setLineParsed(ATTRIBUTE_T);} +| <BEGIN_T: "begin"> +| <BLOCK_T: "block"> +| <BODY_T: "body"> {::vhdl::parser::VhdlParser::setLineParsed(BODY_T);} +| <BUFFER_T: "buffer"> +| <BUS_T: "bus"> +| <COMPONENT_T: "component"> {::vhdl::parser::VhdlParser::setLineParsed(COMPONENT_T);} +| <CASE_T: "case"> +| <CONFIGURATION_T: "configuration"> {::vhdl::parser::VhdlParser::setLineParsed(CONFIGURATION_T);} +| <CONSTANT_T: "constant"> {::vhdl::parser::VhdlParser::setLineParsed(CONSTANT_T);} +| <CONTEXT_T: "context"> {::vhdl::parser::VhdlParser::setLineParsed(CONTEXT_T);} +| <COVER_T: "cover"> +| <DEFAULT_T: "default"> +| <DISCONNECT_T: "disconnect"> +| <DOWNTO_T: "downto"> +| <ELSE_T: "else"> +| <ELSIF_T: "elsif"> +| <END_T: "end"> {::vhdl::parser::VhdlParser::setLineParsed(END_T);} +| <ENTITY_T: "entity"> {::vhdl::parser::VhdlParser::setLineParsed(ENTITY_T);} +| <EXIT_T: "exit"> +| <FAIRNESS_T: "fairness"> +| <FILE_T: "file"> {::vhdl::parser::VhdlParser::setLineParsed(FILE_T);} +| <FOR_T: "for"> +| <FORCE_T: "force"> +| <FUNCTION_T: "function"> {::vhdl::parser::VhdlParser::setLineParsed(FUNCTION_T);} +| <GENERATE_T: "generate"> +| <GENERIC_T: "generic"> +| <GROUP_T: "group"> {::vhdl::parser::VhdlParser::setLineParsed(GROUP_T);} +| <GUARDED_T: "guarded"> +| <IF_T: "if"> +| <IMPURE_T: "impure"> +| <IN_T: "in"> +| <INERTIAL_T: "inertial"> +| <INOUT_T: "inout"> +| <IS_T: "is"> +| <LABEL_T: "label"> +| <LIBRARY_T: "library"> {::vhdl::parser::VhdlParser::setLineParsed(LIBRARY_T);} +| <LINKAGE_T: "linkage"> +| <LITERAL_T: "literal"> +| <LOOP_T: "loop"> +| <MAP_T: "map"> +| <MOD_T: "mod"> +| <NAND_T: "nand"> +| <NEW_T: "new"> +| <NEXT_T: "next"> +| <NOR_T: "nor"> +| <NOT_T: "not"> +| <NULL_T: "null"> +| <OF_T: "of"> +| <ON_T: "on"> +| <OPEN_T: "open"> +| <OR_T: "or"> +| <OTHER_T: "others"> +| <OUT_T: "out"> +| <PACKAGE_T: "package"> {::vhdl::parser::VhdlParser::setLineParsed(PACKAGE_T);} +| <PARAMETER_T: "parameter"> +| <PORT_T: "port"> {::vhdl::parser::VhdlParser::setLineParsed(PORT_T);} +| <POSTPONED_T: "postponed"> +| <PROCEDURE_T: "procedure"> {::vhdl::parser::VhdlParser::setLineParsed(PROCEDURE_T);} +| <PROCESS_T: "process"> {::vhdl::parser::VhdlParser::setLineParsed(PROCESS_T);} +| <PROPERTY_T: "property"> +| <PROTECTED_T: "protected"> +| <PURE_T: "pure"> +| <RANGE_T: "range"> +| <RECORD_T: "record"> {::vhdl::parser::VhdlParser::setLineParsed(RECORD_T);} +| <REGISTER_T: "register"> +| <REJECT_T: "reject"> +| <RELEASE_T: "release"> +| <RESTRICT_T: "restrict"> +| <RESTRICT_GUARANTEE_T: "restrict_guarantee"> +| <REM_T: "rem"> +| <REPORT_T: "report"> +| <ROL_T: "rol"> +| <ROR_T: "ror"> +| <RETURN_T: "return"> +| <SELECT_T: "select"> +| <SEQUENCE_T: "sequence"> +| <SEVERITY_T: "severity"> +| <SIGNAL_T: "signal"> {::vhdl::parser::VhdlParser::setLineParsed(SIGNAL_T);} +| <SHARED_T: "shared"> +| <SLA_T: "sla"> +| <SLL_T: "sll"> +| <SRA_T: "sra"> +| <SRL_T: "srl"> +| <STRONG_T: "strong"> +| <SUBTYPE_T: "subtype"> {::vhdl::parser::VhdlParser::setLineParsed(SUBTYPE_T);} +| <THEN_T: "then"> +| <TO_T: "to"> +| <TRANSPORT_T: "transport"> +| <TYPE_T: "type"> {::vhdl::parser::VhdlParser::setLineParsed(TYPE_T);} +| <UNAFFECTED_T: "unaffected"> +| <UNITS_T: "units"> {::vhdl::parser::VhdlParser::setLineParsed(UNITS_T);} +| <UNTIL_T: "until"> +| <USE_T: "use"> +| <VARIABLE_T: "variable"> +| <VMODE_T: "vmode"> +| <VPROP_T: "vprop"> +| <VUNIT_T: "vunit"> +| <WAIT_T: "wait"> +| <WHEN_T: "when"> +| <WHILE_T: "while"> +| <WITH_T: "with"> +| <XOR_T: "xor"> +| <XNOR_T: "xnor"> +} + +/* OPERATORS */ + +TOKEN : +{ + < AMPERSAND_T: "&" > +| < APOSTROPHE_T: "'" > +| < LPAREN_T: "(" > +| < RPAREN_T: ")" > +| < DOUBLEMULT_T: "**" > +| < MULT_T: "*" > +| < PLUS_T: "+" > +| < MINUS_T: "-" > +| < COMMA_T: "," > +| < VARASSIGN_T: ":=" > +| < COLON_T: ":" > +| < SEMI_T: ";" > +| < LESSTHAN_T: "<=" > +| < GREATERTHAN_T: ">=" > +| < LT_T: "<" > +| < GT_T: ">" > +| < EQU_T: "=" > +| < NOTEQU_T: "/=" > +| < ARROW_T: "=>" > +| < BOX_T: "<>" > +| < SLSL_T: "<<" > +| < RSRS_T: ">>" > +| < QQ_T: "??" > +| < QGT_T: "?>=" > +| < QLT_T: "?<=" > +| < QG_T: "?>" > +| < QL_T: "?<" > +| < QEQU_T: "?=" > +| < QNEQU_T: "?/=" > +| < Q_T: "?" > +| < BAR_T: "|" > +| <DOT_T: "." > +| < SLASH_T: "/" > +| < AT_T: "@" > +| < NEG_T: "^" > +| < LBRACKET_T: "[" > +| < RBRACKET_T: "]" > +| < LBRACE: "{" > +| < RBRACE: "}" > + +} + +TOKEN: +{ + <INTEGER: <DIGIT> ((["_"])? (<DIGIT>))* > + | <STRINGLITERAL: (( ["\""](<GRAPHIC_CHARACTER>)*) "\"")+ > + | <BASIC_IDENTIFIER: (<LETTER> ( (["_"])* <LETTER_OR_DIGIT> )*) > + | <EXTENDED_CHARACTER: ( ["\\"](<GRAPHIC_CHARACTER>)*["\\"] ) > + | <CHARACTER_LITERAL: (["'"]<GRAPHIC_CHARACTER>["'"]) > + | <DECIMAL_LITERAL: (<INTEGER> (["."]<INTEGER>)? (<EXPONENT>)? ) > + | <BASED_INTEGER: <LETTER_OR_DIGIT>( <LETTER_OR_DIGIT>)* > + | <BASED_LITERAL: <INTEGER>["#"]<BASED_INTEGER>(["."] <BASED_INTEGER>)? ["#"] (<EXPONENT>)? > + | <#EXPONENT: (["e","E"] (["+","-"])? (<INTEGER>)+) > + | < #BASIC_GRAPHIC_CHARACTER: (<UPPER_CASE_LETTER>|<DIGIT>|<SPECIAL_CHARACTER>|<SPACE_CHARACTER>) > + | < #GRAPHIC_CHARACTER: ( <BASIC_GRAPHIC_CHARACTER>|<LOWER_CASE_LETTER>|<OTHER_SPECIAL_CHARACTER> ) > + | < #LETTER_OR_DIGIT: ( <LETTER> | <DIGIT> ) > + | < #LETTER: (<UPPER_CASE_LETTER>|<LOWER_CASE_LETTER>) > + | < #UPPER_CASE_LETTER: ["A"-"Z"] > + | <BIT_STRING_LITERAL : <BASE_SPECIFIER >["\""](<LETTER_OR_DIGIT>)* ["\""] > + | <#BASE_SPECIFIER:["B","O","X","b","o","x"]> + | < #DIGIT: ["0"-"9"] > + | < #SPECIAL_CHARACTER: ["#","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","_","|"] > + | < #OTHER_SPECIAL_CHARACTER: ["%","!","$","@","?","[","\\","]","^","`","{","}","~","\u00A0"-"\u00FF"]> + | < #SPACE_CHARACTER: [" ","\t"] > + | < #LOWER_CASE_LETTER: ["a"-"z"] > + | <VHDL2008TOOLDIR : ["`"](<GRAPHIC_CHARACTER>)+ > + + +} + +QCString abstract_literal() : +{Token *tok;} +{ + tok=<DECIMAL_LITERAL> { return tok->image.c_str(); } + | tok=<INTEGER> { return tok->image.c_str(); } + | tok=<BASED_LITERAL> { return tok->image.c_str(); } +} + +QCString access_type_definition() : +{Token *tok;QCString str,str1;} +{ +tok=<ACCESS_T> str1=subtype_indication() {str=tok->image.c_str(); return str+str1;} +} + +QCString actual_designator() : +{QCString str;Token *t;} +{ +t=<OPEN_T> { return t->image.c_str(); } +| +LOOKAHEAD(expression()) + str=expression() { return str; } +| + LOOKAHEAD(name()) + str=name() { return str; } +} + +QCString actual_parameter_part() : +{QCString s;} +{ + s=association_list() { return s;} +} + +QCString actual_part() : +{QCString s,s1;} +{ + LOOKAHEAD(actual_designator()) + s=actual_designator() { return s;} + | + <BOX_T> { return "<>";} + | + s=name() <LPAREN_T> s1=actual_designator() <RPAREN_T> {s+="(";s+=s1+")";return s;} + + } + +QCString adding_operator () : +{} +{ + <PLUS_T> { return "+";} + | <MINUS_T> { return "-";} + |<AMPERSAND_T> { return "&";} +} + +QCString aggregate() : {QCString s,s1,s2;} +{ + <LPAREN_T> s=element_association() (LOOKAHEAD(1)<COMMA_T> s1=element_association(){s+=","+s1;})* <RPAREN_T> { return s;} +} + +QCString alias_declaration() : {QCString s,s1,s2;} +{ + <ALIAS_T> s2=alias_designator() + [ <COLON_T>{ s+=":"; } s1=subtype_indication() { s+=s1; }] + <IS_T> { s+=" is "; } s1=name() {s+=s1;} [s1=signature() {s+=s1;}] + <SEMI_T> +{ + addVhdlType(s2.data(),getLine(ALIAS_T),Entry::VARIABLE_SEC,VhdlDocGen::ALIAS,0,s.data(),Public); + + return s2+" "+s+";"; +} + } + +QCString alias_designator() : {Token *tok=0;QCString s;} +{ + s=identifier() { return s;} + | tok=<CHARACTER_LITERAL> { return tok->image.c_str(); } + | s=operator_symbol() { return s; } +} + +void allocator() :{} +{ + LOOKAHEAD(3) + <NEW_T> qualified_expression() + | <NEW_T> subtype_indication() +} + +void architecture_body() : {QCString s,s1;} +{ + + <ARCHITECTURE_T> s=identifier() <OF_T> s1=name() <IS_T> + { + QCString t=s1+"::"+s; + genLabels.resize(0); + pushLabel(genLabels,s1); + lastCompound=current; + addVhdlType(t,getLine(ARCHITECTURE_T),Entry::CLASS_SEC,VhdlDocGen::ARCHITECTURE,0,0,Private); + } + try{ + architecture_declarative_part() + }catch(...){error_skipto(BEGIN_T);} + <BEGIN_T> + architecture_statement_part() + <END_T> [<ARCHITECTURE_T>] [name()] <SEMI_T> + { lastEntity=0;lastCompound=0; genLabels.resize(0); } +} + +void architecture_declarative_part() : {} +{ + (block_declarative_item() )* +} + +void architecture_statement_part() : {} +{ + (concurrent_statement())* +} + +QCString array_type_definition (): { QCString s;} +{ + + LOOKAHEAD(unconstraint_array_definition()) + + s=unconstraint_array_definition() {return s;} + | s=constraint_array_definition() {return s;} + +} + +QCString assertion() : {QCString s,s1,s2;Token *t=0;Token *t1=0;} +{ + <ASSERT_T> s=condition() [ t=<REPORT_T> s1=expression() ] [t1=<SEVERITY_T> s2=expression()] + { + s.prepend("assert "); + if(t) s1.prepend(" report "); + if(t1) s2.prepend(" report "); + return s+s1+s2; + } +} + +QCString assertion_statement() : {QCString s,s1,s2;Token *t=0;} +{ + [ s=label() t=<COLON_T> ] s1=assertion() <SEMI_T> + { + if(t) s+=":"; + return s+s1+";"; + } +} +QCString association_element() : {} +{ + [LOOKAHEAD(formal_part() <ARROW_T>) formal_part() <ARROW_T> ] actual_part() + { return " ";} +} + +QCString association_list (): {QCString s,s1;} +{ +s=association_element() (<COMMA_T> s1=association_element() { s+=","+s1; })* { return s; } +} + +QCString attribute_declaration() : {QCString s,s1;} +{ + <ATTRIBUTE_T> s=identifier() <COLON_T> s1=type_mark() <SEMI_T> + { + addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,s1.data(),Public); + return " attribute "+s+":"+s1+";"; + } + } + +QCString attribute_designator (): {QCString s;Token *tok;} +{ + s=identifier() { return s;} + | tok=<RANGE_T> { return tok->image.c_str(); } +} + +QCString attribute_name (): {QCString s,s1;} +{ + s=identifier() <APOSTROPHE_T> s1=name(){ s+="'"+s1; }[LOOKAHEAD(1)<LPAREN_T>s1=expression() <RPAREN_T> {s+"("+s1+")";}] { return s; } +} + + +QCString attribute_specification(): {QCString s,s1,s2;} +{ + <ATTRIBUTE_T> s=attribute_designator() <OF_T> s1=entity_specification() <IS_T> s2=expression() <SEMI_T> + { + QCString t= s1+" is "+s2; + addVhdlType(s.data(),getLine(ATTRIBUTE_T),Entry::VARIABLE_SEC,VhdlDocGen::ATTRIBUTE,0,t.data(),Public); + return " attribute "+s+" of "+s1+ " is "+s2+";"; + } +} + +QCString base() : {Token *tok;} +{ + tok=<INTEGER> { return tok->image.c_str();} +} + +QCString base_specifier (): {Token *tok;} +{ + tok=<BASIC_IDENTIFIER> { return tok->image.c_str();} +} + +QCString base_unit_declaration() : +{QCString s;} +{ + s=identifier() { return s; } +} + +QCString based_integer() : {Token *tok;} +{ + tok=<BASIC_IDENTIFIER> { return tok->image.c_str();} +} + +QCString based_literal(): {Token *tok;} +{ + tok=<BASED_LITERAL> { return tok->image.c_str();} +} + +QCString basic_identifier() : {Token *tok;} +{ + tok=<BASIC_IDENTIFIER> { return tok->image.c_str();} +} + +void binding_indication() : {} +{ + [ <USE_T> entity_aspect() ] + [ generic_map_aspect() ] + [ port_map_aspect() ] +} + +QCString bit_string_literal (): {Token *tok;} +{ + tok=<BIT_STRING_LITERAL> { return tok->image.c_str();} +} + + +QCString bit_value() : {Token *tok;} +{ + tok=<BASIC_IDENTIFIER> { return tok->image.c_str();} +} + +void block_configuration() : {} +{ + <FOR_T> block_specification() + ( use_clause() )* + ( configuration_item())* + <END_T> <FOR_T> <SEMI_T> +} + +void block_declarative_item (): {} +{ + subprogram_declaration() +//| subprogram_body() +| type_declaration() +| subtype_declaration() +| constant_declaration() +| signal_declaration() +| variable_declaration() +| file_declaration() +| alias_declaration() +| component_declaration() +| +LOOKAHEAD(attribute_declaration()) +attribute_declaration() +| attribute_specification() +| configuration_specification() +| disconnection_specification () +| use_clause() +| +LOOKAHEAD(3) +group_template_declaration() +| group_declaration() +} + +void block_declarative_part() : {} +{ + (block_declarative_item() )* +} + +void block_header() : {} +{ +[LOOKAHEAD(generic_clause()) generic_clause()[ generic_map_aspect() <SEMI_T> ] ] +[ port_clause() [ port_map_aspect() <SEMI_T> ] ] +} + +void block_specification() : {} +{ + name()[LOOKAHEAD(1) <LPAREN_T> index_specification() <RPAREN_T>] +} + +void block_statement() : {QCString s;} +{ + s=identifier() <COLON_T> + <BLOCK_T> { pushLabel(genLabels,s); }[ <LPAREN_T> expression() <RPAREN_T> ] [ <IS_T> ] + block_header() + block_declarative_part() + <BEGIN_T> + block_statement_part() + <END_T> <BLOCK_T> [ identifier() ] <SEMI_T> + { + genLabels=popLabel(genLabels); + } +} + +void block_statement_part() : {} +{ + ( concurrent_statement() )* +} + +void case_statement() : {QCString s;} +{ +[ identifier() <COLON_T> ] + <CASE_T> s=expression() + { + QCString ca="case "+s; + FlowChart::addFlowChart(FlowChart::CASE_NO,0,ca); + } + <IS_T> + case_statement_alternative() + ( case_statement_alternative ())* + <END_T> <CASE_T> [ identifier() ] <SEMI_T> + { + FlowChart::moveToPrevLevel(); + FlowChart::addFlowChart(FlowChart::END_CASE,0,0); + } +} + +void case_statement_alternative() : {QCString s;} +{ + <WHEN_T> s=choices() <ARROW_T> + { + QCString t="when "; + t+=s+"=> "; + FlowChart::addFlowChart(FlowChart::WHEN_NO,s.data(),t); + } + sequence_of_statement(){FlowChart::moveToPrevLevel(); } +} + +QCString character_literal() : {Token *tok;} +{ + tok=<CHARACTER_LITERAL>{ return tok->image.c_str();} +} + +QCString choice() : {QCString s;} +{ + LOOKAHEAD(discrete_range()) + s=discrete_range(){ return s; } + | + LOOKAHEAD(simple_expression()) + s=simple_expression(){ return s; } + | s=identifier(){ return s; } + | <OTHER_T> { return " others "; } +} + +QCString choices() : {QCString s,s1;} +{ + s=choice() (<BAR_T> choice(){s+="|";s+=s1;})* { return s; } +} + +void component_configuration () :{} +{ + <FOR_T> component_specification() + [ binding_indication() <SEMI_T> ] + [ block_configuration() ] + <END_T> <FOR_T> <SEMI_T> +} +void component_declaration() : {QCString s;} +{ + <COMPONENT_T> s=identifier() [ <IS_T> ] + { currP=VhdlDocGen::COMPONENT; } + [ generic_clause() ] + [ port_clause() ] + { + addVhdlType(s.data(),getLine(COMPONENT_T),Entry::VARIABLE_SEC,VhdlDocGen::COMPONENT,0,0,Public); + currP=0; + } + <END_T> <COMPONENT_T> [ identifier() ] <SEMI_T> + +} + +void component_instantiation_statement() : {QCString s,s1;} +{ + +s=identifier() <COLON_T> + s1=instantiation_unit() + { + addCompInst(s.lower().data(),s1.lower().data(),0,getLine()); + } + [ LOOKAHEAD(generic_map_aspect()) generic_map_aspect() ] + [ port_map_aspect() ] <SEMI_T> +} + +void component_specification() : {} +{ +instantiation_list() <COLON_T> name() +} + +QCString composite_type_definition() : { QCString s,s1;} +{ + s=array_type_definition(){ return s; } +| record_type_definition(){ return s; } +} + +void concurrent_assertion_statement() : {} +{ +[ LOOKAHEAD(2) identifier() <COLON_T> ] [ <POSTPONED_T> ] assertion() <SEMI_T> +} + +void concurrent_procedure_call_statement() : {} +{ +[ LOOKAHEAD(2) identifier() <COLON_T> ] [ <POSTPONED_T> ] procedure_call() <SEMI_T> +} + +void concurrent_signal_assignment_statement() : {} +{ +[ LOOKAHEAD(2) identifier() <COLON_T> ] [<POSTPONED_T> ] +( +LOOKAHEAD(conditional_signal_assignment() ) + conditional_signal_assignment() +| selected_signal_assignment() + +) +} + +void concurrent_statement() : {} +{ + +// try { +LOOKAHEAD([identifier() ":"] <BLOCK_T>) +block_statement() +| +LOOKAHEAD([identifier() ":"] [<POSTPONED_T>] <PROCESS_T>) +process_statement() +| +LOOKAHEAD(generate_statement()) +generate_statement() +| +case_scheme() +| +LOOKAHEAD([identifier() ":"] [<POSTPONED_T>] <ASSERT_T>) +concurrent_assertion_statement() +| +LOOKAHEAD(concurrent_signal_assignment_statement()) + concurrent_signal_assignment_statement() +| +LOOKAHEAD(component_instantiation_statement() ) +component_instantiation_statement() +| +LOOKAHEAD(concurrent_procedure_call_statement()) +concurrent_procedure_call_statement() + /* + } + catch( ParseException e ) + { + error_skipto(SEMI_T, "syntax error in declarative item"); + } + */ +} + +QCString condition() : {QCString s;} +{ + s=expression() { return s; } +} + +QCString condition_clause() : {QCString s;} +{ + <UNTIL_T> s=condition() + { + return " until "+s; + } +} + +void conditional_signal_assignment() : {} +{ + // LOOKAHEAD( target() "<=" options_() conditional_waveforms() ";") + target() <LESSTHAN_T> options() conditional_waveforms() <SEMI_T> +} + +void conditional_waveforms() : {} +{ +waveform() + ( LOOKAHEAD(<WHEN_T> condition() <ELSE_T>) + <WHEN_T> condition() <ELSE_T> waveform() )* + [ <WHEN_T> condition() ] +} + +// ( waveform() < WHEN_T> condition() <ELSE_T> )* +// waveform() [ <WHEN_T> condition() ] + +//waveform() + // ( LOOKAHEAD( <WHEN> condition() <ELSE>) + // <WHEN> condition() <ELSE> waveform() )* + //[ <WHEN> condition() ] + +void configuration_declaration() : {QCString s,s1;} +{ + <CONFIGURATION_T> s=identifier() <OF_T> s1=name() <IS_T> + { + + confName=s+"::"+s1; + addVhdlType(s.data(),getLine(CONFIGURATION_T),Entry::VARIABLE_SEC,VhdlDocGen::CONFIG,"configuration",s1.data(),Public); + } + configuration_declarative_part() + block_configuration() + <END_T> [ <CONFIGURATION_T> ] [ name() ] <SEMI_T> + { genLabels.resize(0); confName="";} +} + +void configuration_declarative_item() : {} +{ + use_clause() +| attribute_specification() +| group_declaration() +} + +void configuration_declarative_part() : {} +{ + (configuration_declarative_item())* +} + +void configuration_item (): {} +{ + LOOKAHEAD(component_configuration()) + component_configuration() + | block_configuration() + +} + +void configuration_specification() : {} +{ +<FOR_T> component_specification() binding_indication() <SEMI_T> +} + +QCString constant_declaration() : {QCString s,s1,s2;Token *t=0;} +{ + <CONSTANT_T> s=identifier_list() <COLON_T> s1= subtype_indication() [ t=<VARASSIGN_T> s2=expression() ] <SEMI_T> + { + if(t) + s2.prepend(":="); + QCString it=s1+s2; + addVhdlType(s.data(),getLine(CONSTANT_T),Entry::VARIABLE_SEC,VhdlDocGen::CONSTANT,0,it.data(),Public); + it.prepend("constant "); + return it; + } +} + +QCString constraint_array_definition (): {QCString s,s1;} +{ +<ARRAY_T> s=index_constraint() <OF_T> s1=subtype_indication(){ return s+" "+s1;} +} + +void context_clause (): {} +{ + (context_item())* +} + +QCString constraint () :{QCString s;} + { + LOOKAHEAD(range_constraint()) + s=range_constraint(){ return s;} + | + LOOKAHEAD(index_constraint()) + s=index_constraint(){ return s;} +} + +void context_item() : {} +{ + library_clause() +| use_clause() +} + +QCString decimal_literal() : {Token *tok;} +{ + tok=<DECIMAL_LITERAL> { return tok->image.c_str(); } +} + + +QCString delay_mechanism (): {QCString s;} +{ +<TRANSPORT_T> { return " transport ";} +| [ <REJECT_T> s=expression() {s.prepend(" reject ");}] <INERTIAL_T> { return s+" inertial "; } +} + +void design_file() : {} +{ + (design_unit() )+ {} + | <EOF> +} + +void design_unit() : {} +{ + context_clause()library_unit() + +} + +QCString designator() : {QCString s;} +{ + s=identifier() {return s;} + | s=operator_symbol(){return s;} +} + +QCString direction (): {Token *tok;} +{ +tok=<TO_T> { return tok->image.c_str();} +| tok=<DOWNTO_T> { return tok->image.c_str();} +} + +void disconnection_specification() : {} +{ +<DISCONNECT_T> guarded_signal_specificatio() <AFTER_T> expression() <SEMI_T> +} + +void guarded_signal_specificatio() : {} +{ + signal_list() <COLON_T> name() +} + +QCString discrete_range() : {QCString s;} +{ + LOOKAHEAD(range()) + s=range() { return s;} + | + LOOKAHEAD(subtype_indication()) + s=subtype_indication() { return s;} +} + +QCString element_association() : {QCString s,s1;} +{ + [LOOKAHEAD(choices() <ARROW_T>) choices() <ARROW_T> ] s1=expression() { return s1;} +} + +QCString element_declaration() : {QCString s,s1;} +{ +s=identifier_list() <COLON_T> s1=subtype_indication() <SEMI_T> {return s+":"+s1;} +} + + +QCString entity_aspect() : {Token *tok;QCString s,s1;} +{ +tok=<ENTITY_T> s=name() [ LOOKAHEAD(1)<LPAREN_T> s1=identifier() <RPAREN_T> {s+="("+s1+")";} ] { return s;} +| tok=<CONFIGURATION_T> s=name() { return tok->image.c_str()+s;} +| tok=<OPEN_T> { return tok->image.c_str(); } +} + +QCString entity_class() : {} +{ +<ENTITY_T> { return "entity";} +| <ARCHITECTURE_T> {return "architecture";} +| <CONFIGURATION_T> {return "configuration";} +| <PROCEDURE_T> {return "procedure";} +| <FUNCTION_T> {return "function";} +| <PACKAGE_T> {return "package";} +| <TYPE_T> {return "type";} +| <SUBTYPE_T> {return "subtype";} +| <CONSTANT_T> {return "constant";} +| <SIGNAL_T> {return "signal";} +| <VARIABLE_T> {return "variable";} +| <COMPONENT_T> {return "component";} +| <LABEL_T> {return "label";} +| <LITERAL_T> {return "literal";} +| <UNITS_T> {return "units";} +| <GROUP_T> {return "group";} +| <FILE_T> {return "file";} +} + +QCString entity_class_entry() : {QCString s;} +{ + s=entity_class() [ <BOX_T> {s+="<>";} ] { return s;} +} + +QCString entity_class_entry_list() : {QCString s,s1,s2;} +{ + ( s1=entity_class_entry() {s+=s1;} )(<COMMA_T> s=entity_class_entry(){s2+=",";s2+=s;} )* { return s1+s2;} +} + +void entity_declaration() : {QCString s;} +{ + try{ + <ENTITY_T> s=identifier() <IS_T> + { + lastEntity=current; + lastCompound=0; + addVhdlType(s.data(),getLine(ENTITY_T),Entry::CLASS_SEC,VhdlDocGen::ENTITY,0,0,Public); + } + entity_header() + entity_declarative_part () + [ <BEGIN_T> entity_statement_part() ] + <END_T> [ <ENTITY_T> ] [ name() ] + }catch(...){error_skipto(SEMI_T);} + <SEMI_T> + { lastEntity=0;lastCompound=0; genLabels.resize(0); } +} + +void entity_declarative_item() : {} +{ +subprogram_declaration() +//| subprogram_body() +| type_declaration() +| subtype_declaration() +| constant_declaration() +| signal_declaration() +| variable_declaration() +| file_declaration() +| alias_declaration() +| +LOOKAHEAD(attribute_declaration()) +attribute_declaration() +| attribute_specification() +| disconnection_specification() +| use_clause() +| +LOOKAHEAD(3) +group_template_declaration() +| group_declaration() +| +LOOKAHEAD(5) + package_instantiation_declaration() +|package_declaration() +} + +void entity_declarative_part() : {} +{ + (entity_declarative_item() )* +} + +QCString entity_designator() : {QCString s,s1;} +{ +s=entity_tag() [ s1=signature() ] { return s+s1;} +} + +void entity_header() : {} +{ + [ { currP=VhdlDocGen::GENERIC;parse_sec=GEN_SEC; } generic_clause()] + [ { currP=VhdlDocGen::PORT; } port_clause()] +} + +QCString entity_name_list() : {QCString s,s1;} +{ +(s1=entity_designator() {s+=s1;})+ { return s;} +| <OTHER_T> { return "other";} +| <ALL_T> {return "all";} +} + +QCString entity_specification() : {QCString s,s1;} +{ +s=entity_name_list() <COLON_T> s1=entity_class(){ return s+":"+s1;} +} + +void entity_statement() : {} +{ +LOOKAHEAD(concurrent_assertion_statement()) +concurrent_assertion_statement() +| +LOOKAHEAD(process_statement()) + process_statement() +| concurrent_procedure_call_statement() + +} + +void entity_statement_part() : {} +{ + (entity_statement())* +} + + +QCString entity_tag (): {QCString s;} +{ +s=name() { return s;} +| s=character_literal() { return s;} +} + +QCString enumeration_literal() : {QCString s;} +{ + s=identifier() { return s;} + | s=character_literal() { return s;} +} + +QCString enumeration_type_definition() : {QCString s,s1;} +{ + <LPAREN_T>s=enumeration_literal() (LOOKAHEAD(1)<COMMA_T> s1=enumeration_literal() {s+=",";s+=s1;} )* <RPAREN_T> + { return "("+s+")";} +} + +QCString exit_statement() : {QCString s,s1,s2;Token *t=0;Token *t1=0;} +{ +[ s=identifier() t=<COLON_T> ] <EXIT_T> [ s1=identifier() ] +[ t1=<WHEN_T> s2=condition() ] <SEMI_T> +{ + if(t) s+=":"; + if(t1) s2.prepend(" when "); + return s+s1+s2+";"; +} +} + +QCString expression (): {QCString s,s1,s2;} +{ +s=relation() ( s1=logop() s2=relation() {s+=s1;s+=s2;} )* +{ return s; } +} + +QCString logop() : {} +{ + <AND_T> { return "and" ;} + |<NAND_T> { return "nand" ;} + |<NOR_T> { return "nor" ;} + |<XNOR_T> { return "xnor" ;} + |<XOR_T> { return "xor" ;} + |<OR_T> { return "or" ;} + +} + +QCString extended_identifier (): {Token *t;} +{ + t=<EXTENDED_CHARACTER> { return t->image.c_str(); } +} + +QCString factor(): {QCString s,s1;} +{ +s=primary() [LOOKAHEAD(1) <DOUBLEMULT_T> s1=primary(){ s+="**";s+=s1;} ] { return s;} +| <ABS_T> s=primary(){ s1 = "abs "; return s1+s; } +| <NOT_T> s=primary(){s1="not ";return s1+s;} +} + +QCString file_declaration() : {QCString s,s1,s2,s3;} +{ + <FILE_T> s=identifier_list() <COLON_T> s2=subtype_indication() [ s3=file_open_information() ] <SEMI_T> + { + QCString t1=s2+" "+s3; + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,t1.data(),Public); + return " file "+s+":"+s2+" "+s3+";"; + } + } + +QCString file_logical_name(): {QCString s;} +{ + s=expression() { return s; } +} + +QCString file_open_information() : {QCString s,s1,s2;} +{ + [ <OPEN_T> s=expression() ] <IS_T> s1=file_logical_name() {s2="open "+s+" is "+s1; return s2; } +} + +QCString file_type_definition() : {QCString s,s1;} +{ + <FILE_T> <OF_T> s=type_mark() { s1=" file of "+s; return s1;} +} + +QCString floating_type_definition() : {QCString s;} +{ + s=range_constraint(){ return s;} +} + +QCString formal_designator() : {QCString s;Token *tok;} +{ + s=name() { return s; } + |tok=<INTEGER> { return tok->image.c_str();} +} + + +QCString formal_parameter_list() : {QCString s;} +{ + s=interface_list(){ return s; } +} + +QCString formal_part() : {QCString s,s1;} +{ +s=name() [<LPAREN_T> formal_designator() <RPAREN_T> {s+"("+s1+")";}] {return s;} +} + +QCString full_type_declaration() : {QCString s,s1,s2;} +{ +<TYPE_T> s=identifier() <IS_T> + try{ + s2=type_definition() + }catch(...){error_skipto(SEMI_T);} + <SEMI_T> + { + addVhdlType(s.data(),getLine(TYPE_T),Entry::VARIABLE_SEC,VhdlDocGen::TYPE,0,s2.data(),Public); + return "type "+s+" is "+s2+";"; + } +} + +QCString function_call() : {QCString s,s1;} +{ +s=name() <LPAREN_T> s1=actual_parameter_part() <RPAREN_T> { return s+"("+s1+")";} +} + +void generate_statement() : {QCString s;} +{ +s=identifier() <COLON_T> + try{ + generate_scheme() <GENERATE_T> + { pushLabel(genLabels,s); } + [ (block_declarative_item() )* <BEGIN_T> ] (concurrent_statement())* + <END_T> + }catch(...){error_skipto(GENERATE_T);} + <GENERATE_T> [ identifier() ] <SEMI_T> {genLabels=popLabel(genLabels); } +} + +void generate_scheme() : {} +{ +<FOR_T> parameter_specification() +| <IF_T> condition() +} + +void generic_clause() : {QCString s;} +{ + <GENERIC_T> <LPAREN_T> { parse_sec=GEN_SEC; } s=generic_list() <RPAREN_T> <SEMI_T> { parse_sec=0; } +} + +QCString generic_list() : {QCString s;} +{ + s=interface_list() { return s; } +} + +void generic_map_aspect() : {} +{ + <GENERIC_T> <MAP_T> <LPAREN_T> association_list() <RPAREN_T> +} + +QCString group_constituent() : {QCString s;} +{ + s=name() { return s; } + | s=character_literal() { return s;} +} + +QCString group_constituent_list() : {QCString s,s1,s2;} +{ + (s1=group_constituent())(<COMMA_T> s=group_constituent(){s2+=",";s2+=s1;})* { return s+s2;} +} + +QCString group_declaration() : {QCString s,s1,s2;} +{ + <GROUP_T> s=identifier() <COLON_T> s1=identifier() <LPAREN_T> s2=group_constituent_list() <RPAREN_T> <SEMI_T> + { + return "group "+s+":"+s1+"("+s2+");"; + } +} + +QCString group_template_declaration() : {QCString s,s1;} +{ + <GROUP_T> s=identifier() <IS_T> <LPAREN_T> s1=entity_class_entry_list() <RPAREN_T> <SEMI_T> + { + return "group "+s+ "is ("+s1+");"; + } + } + +void guarded_signal_specification() : {} +{ + signal_list() <COLON_T> type_mark() +} + +QCString identifier() : {Token *tok;} +{ + tok=<EXTENDED_CHARACTER>{ return tok->image.c_str(); } + |tok=<BASIC_IDENTIFIER> { return tok->image.c_str(); } +} + +QCString identifier_list() : {QCString str,str1;} +{ + str=identifier() (<COMMA_T> str1=identifier() {str+=",";str+=str1;})* { return str; } +} + +void if_statement() : {QCString s,s1;} +{ +[LOOKAHEAD(1) identifier() <COLON_T> ] + <IF_T> s=condition() <THEN_T> + { + s.prepend("if "); + FlowChart::addFlowChart(FlowChart::IF_NO,0,s); + } + sequence_of_statement() + ( + <ELSIF_T> s1=condition() <THEN_T> + { + s1.prepend("elsif "); + FlowChart::addFlowChart(FlowChart::ELSIF_NO,0,s1.data()); + } + sequence_of_statement() + )* + [LOOKAHEAD(1) <ELSE_T> + { + FlowChart::addFlowChart(FlowChart::ELSE_NO,0,0); + } + sequence_of_statement() ] <END_T> <IF_T> [ identifier() ] <SEMI_T> + { + FlowChart::moveToPrevLevel(); + FlowChart::addFlowChart(FlowChart::ENDIF_NO,0,0); + } +} + +QCString incomplete_type_declaration() : {QCString s;} +{ + <TYPE_T> s=identifier() <SEMI_T> + { + return "type "+s+";"; + } +} + +QCString index_constraint() : {QCString s="("; QCString s1,s2;} +{ + //try{ + <LPAREN_T> s2=discrete_range(){s+=s2;}(LOOKAHEAD(1)<COMMA_T> s1=discrete_range(){s+=",";s+=s1;})* <RPAREN_T> {return s+")";} +//}catch(...){ error_skipto(SEMI_T);hasError=false;return "";} + } + +QCString index_specification() : {QCString s;} +{ + LOOKAHEAD( discrete_range()) + s=discrete_range() { return s;} +| s=expression(){ return s;} +} + +QCString index_subtype_definition() : {QCString s;} +{ + s=type_mark() <RANGE_T> <BOX_T> { return s+" range <> ";} +} + +QCString instantiation_unit() : {QCString s,s1,s2;Token *tok;} +{ +[ tok=<COMPONENT_T> ] s=identifier() {s1="component"; return s; } +| tok=<ENTITY_T> s2=name() {s=tok->image.c_str()+s2;} [ <LPAREN_T> s1=identifier() <RPAREN_T> {s+="(";s+=s1;s+=")" ;}] { return s;} +| <CONFIGURATION_T> s=name() {s1="configuration ";return s;} +} + +QCString instantiation_list() : {QCString s;Token *tok;} +{ + s=identifier_list() { return s;} +| tok=<OTHER_T> {return tok->image.c_str();} +| tok=<ALL_T> {return tok->image.c_str();} +} + +QCString integer() : {Token *t;} +{ + t=<INTEGER> {return t->image.c_str();} +} + +QCString integer_type_definition() : {QCString s;} +{ + s=range_constraint(){ return s;} +} + +QCString interface_declaration() : {QCString s,s1;} +{ + +LOOKAHEAD(5) + s=interface_subprogram_declaration() { return s;} + +|interface_package_declaration() { return s;} +| + LOOKAHEAD(5) + s=interface_variable_declaration() { return s;} +| +LOOKAHEAD(5) +interface_file_declaration() { return s;} +| +LOOKAHEAD(subprogram_declaration()) +subprogram_declaration() { return s;} +| + s=object_class() s1=identifier() + { + if (parse_sec==GEN_SEC) + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,s1.data(),0,Public); + return s; + } +} + +QCString interface_element() : {QCString s;} +{ +s=interface_declaration(){ return s;} +} + +QCString interface_file_declaration() : {QCString s,s1;} +{ +<FILE_T> s=identifier_list() <COLON_T> s1=subtype_indication() +{ + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::VFILE,0,s1.data(),Public); + return " file "+s+":"+s1; +} +} + +QCString interface_list() : {QCString s,s1,s2;} +{ +s=interface_element() (LOOKAHEAD(1) <SEMI_T> s1=interface_element(){s2+=";";s2+=s1;})* { return s+s2;} +} + + + +QCString interface_variable_declaration() : {Token *tok=0;Token *tok1=0;Token *tok2=0;QCString s,s1,s2,s3,s4,s5;} +{ +[( tok=<VARIABLE_T> | tok=<SIGNAL_T> | tok=<CONSTANT_T>|tok=<SHARED_T>) ] + s=identifier_list() <COLON_T> [ s1=mode() ] + s2=subtype_indication() [ tok1=<BUS_T> ] [ tok2=<VARASSIGN_T> s4=expression() ] +{ + if(tok) + s5=tok->image.c_str(); + + if(tok1) + s3=tok->image.data(); + + if(tok2) + s3+=":="; + + QCString it=s+":"+s1+" "+s2+" "+s3+" "+s4; + if (currP!=VhdlDocGen::COMPONENT) + { + if (currP==VhdlDocGen::FUNCTION || currP==VhdlDocGen::PROCEDURE) + { + addProto(s5.data(),s.data(),s2.data(),s3.data(),0,s4.data()); + } + else + { + QCString i=s2+s3+s4; + if (currP==VhdlDocGen::GENERIC && param_sec==0) + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public); + else if(parse_sec != GEN_SEC) + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,currP,i.data(),s1.data(),Public); + } + // fprintf(stderr,"\n\n <<port %s >>\n",$$.data()); + } // if component + return it; + } +} + +void iteration_scheme() : {} +{ +<WHILE_T> condition() +| <FOR_T> parameter_specification() +} + +QCString label() : {QCString s;} +{ + s=identifier() { return s;} +} + +QCString library_clause() : {QCString s;} +{ + (<LIBRARY_T> s=identifier_list() <SEMI_T> + ) + { + if ( parse_sec==0 && Config_getBool("SHOW_INCLUDE_FILES") ) + { + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,s.data(),"_library_",Public); + } + QCString s1="library "+s; + return s1; + } +} + +QCString library_unit() : {QCString s;} +{ +LOOKAHEAD(2) +primary_unit() { return s; } +| secondary_unit() { return s; } +| context_declaration() + +} + +QCString literal() : {QCString s;} +{ + + LOOKAHEAD(bit_string_literal()) +s=bit_string_literal() { return s;} +| + LOOKAHEAD(numeric_literal()) + s=numeric_literal() { return s;} +| + +LOOKAHEAD(enumeration_literal()) +s=enumeration_literal() { return s;} +| s=string_literal() { return s;} +| <NULL_T> {return "null";} +} + +QCString logical_operator() : {QCString s;} +{ + s=logop() { return s;} +} + +void loop_statement() : {} +{ +[ identifier() <COLON_T> ] + [ iteration_scheme() ] <LOOP_T> + sequence_of_statement() + <END_T> <LOOP_T> [ identifier() ] <SEMI_T> +} + + +QCString miscellaneous_operator():{Token *t=0;} +{ + <DOUBLEMULT_T> {return "**";} + | <ABS_T> {return "abs";} + | <NOT_T> {return "not";} +} + +QCString mode() : {Token *tok;} +{ +tok=<IN_T> { return "in"; } +| tok=<OUT_T> { return "out"; } +| tok=<INOUT_T> { return "inout"; } +| tok=<BUFFER_T> { return "buffer"; } +| tok=<LINKAGE_T> { return "linkage"; } +} + +QCString multiplying_operation() : {Token *tok;} +{ +tok=<MULT_T> { return tok->image.c_str(); } +| tok=<SLASH_T> { return tok->image.c_str(); } +| tok=<MOD_T> { return tok->image.c_str(); } +| tok=<REM_T> { return tok->image.c_str(); } +} + + + QCString name() : {QCString s,s1;} +{ + ( + s=operator_symbol() + | s=identifier()| s=external_name() + ) + [LOOKAHEAD(name_ext1()) s1=name_ext1(){ s+=s1;}] { return s; } +} + +QCString name_ext1() : {QCString s,s1,s2;} + { + s=name_ext() (LOOKAHEAD(name_ext()) s1=name_ext(){s+=s1;})* { return s;} + } + + QCString name_ext() : {QCString s,s1,s2;} + { + + ( + LOOKAHEAD(<DOT_T> suffix()) + <DOT_T> s1=suffix(){s+=".";s+=s1;} +| + LOOKAHEAD(test_att_name()) + s1=test_att_name() { s+=s1;} + | + LOOKAHEAD( <LPAREN_T> discrete_range() <RPAREN_T>) + <LPAREN_T> s1=discrete_range() <RPAREN_T> {s+="(";s+=s1;s+=")";} + | + LOOKAHEAD( "(" expression() ("," expression() )* ")" ) + <LPAREN_T> s1=expression() {s+="(";s+=s1;} (LOOKAHEAD(1) <COMMA_T> s1=expression(){s+=",";s+=s1;})* <RPAREN_T> { s+=")";} + + ) + {return s;} + } + + QCString test_att_name() : {QCString s,s1;} + { + [ LOOKAHEAD(<LBRACKET_T>) s1=signature() {s=s1;}] + <APOSTROPHE_T> s1=attribute_designator() {s+="'";s+=s1;} + [LOOKAHEAD(1) <LPAREN_T> s1=expression() <RPAREN_T> {s+="(";s+=s1;s+=")";}] + { return s;} + } + + QCString indexed_name() : {QCString s,s1,s2;} + { + s2=identifier() <LPAREN_T> s1=expression(){s=s2+"("+s1;} (<COMMA_T> s1=expression(){s+=",";s+=s1;})* <RPAREN_T> {return s+")";} + } + +QCString next_statement() : {QCString s,s1,s2;Token *t=0;Token *t1=0;} +{ +[LOOKAHEAD(1) s=identifier() t=<COLON_T> ] <NEXT_T> [ s1=identifier() ] +[LOOKAHEAD(1) t1=<WHEN_T> s2=condition() ] <SEMI_T> +{ + if(t) s+=":"; + if(t1) s2.prepend("when "); + return s+s1+s2+";"; +} +} + +QCString null_statement() : {QCString s;} +{ +[ s=identifier() <COLON_T> {s+=":";}] <NULL_T> <SEMI_T>{return s+="null";} +} + +QCString numeric_literal() : {QCString s;} +{ + + LOOKAHEAD(physical_literal()) + s=physical_literal(){ return s;} + | s=abstract_literal() { return s;} +} + +QCString object_class() : {} +{ +<CONSTANT_T> { return "constant"; } +|<SIGNAL_T> { return "signal"; } +|<VARIABLE_T> { return "variable"; } +|<SHARED_T> <VARIABLE_T> { return "shared variable"; } +|<FILE_T> { return "file"; } +|<TYPE_T> { return "type"; } +} + +QCString operator_symbol() : {Token *tok;} +{ +tok=<STRINGLITERAL> {return tok->image.c_str();} +} + +void options() : {} +{ + [ <GUARDED_T> ] [ delay_mechanism() ] +} + +void package_body() : {QCString s;} +{ +<PACKAGE_T> <BODY_T> s=name() <IS_T> + { + lastCompound=current; + s.prepend("_"); + addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE_BODY,0,0,Protected); + } + package_body_declarative_part() + +<END_T> [<PACKAGE_T> <BODY_T> ] [ name() ] <SEMI_T> { lastCompound=0; genLabels.resize(0); } +} + +void package_body_declarative_item() : {} +{ +subprogram_declaration() +//| subprogram_body() +| type_declaration() +| subtype_declaration() +| constant_declaration() +| variable_declaration() +| file_declaration() +| alias_declaration() +| use_clause() +| +LOOKAHEAD(3) +group_template_declaration() +| group_declaration() +} + +void package_body_declarative_part() : {} +{ +(package_body_declarative_item() )* +} + +void package_declaration(): {QCString s;} +{ + + <PACKAGE_T> s=identifier() <IS_T> + { + lastCompound=current; + Entry *clone=new Entry(*current); + clone->section=Entry::NAMESPACE_SEC; + clone->spec=VhdlDocGen::PACKAGE; + clone->name=s; + clone->startLine=getLine(); + clone->bodyLine=getLine(); + clone->protection=Package; + current_root->addSubEntry(clone); + addVhdlType(s,getLine(),Entry::CLASS_SEC,VhdlDocGen::PACKAGE,0,0,Package); + } + package_declarative_part() +<END_T> [ <PACKAGE_T>] [ name() ] <SEMI_T> +{ lastEntity=0;lastCompound=0; genLabels.resize(0); } +} + +void geninter():{} +{ + [gen_interface_list() <SEMI_T> [gen_assoc_list() <SEMI_T>]] +} + +void package_declarative_item() : {} +{ +//LOOKAHEAD(3) +//interface_subprogram_declaration() +subprogram_declaration() +| type_declaration() +| subtype_declaration() +| constant_declaration() +| signal_declaration() +| variable_declaration() +| file_declaration() +| alias_declaration() +| component_declaration() +| +LOOKAHEAD(attribute_declaration()) + attribute_declaration() +| attribute_specification() +| disconnection_specification() +| use_clause() +| +LOOKAHEAD(3) + group_template_declaration() +| group_declaration() +| + LOOKAHEAD(5) + package_instantiation_declaration() +|package_declaration() + +} + +void package_declarative_part() : {} +{ + (package_declarative_item())* +} + +QCString parameter_specification() : {QCString s,s1;} +{ +s=identifier() <IN_T> s1=discrete_range(){ return s+" in "+s1;} +} + +QCString physical_literal() : {QCString s,s1;} +{ + [LOOKAHEAD(abstract_literal()) s=abstract_literal()] s1=name(){s+=" ";s+=s1;s.prepend(" "); return s;} +} + +QCString physical_type_definition() : {QCString s,s1,s2;} +{ + <UNITS_T> + s=identifier()<SEMI_T> + (s1=secondary_unit_declaration(){s2+=s1;s2+="#";})* + <END_T> <UNITS_T> [name()] + { + current->args=s2; + current->args.prepend("units"); + current->spec=VhdlDocGen::UNITS; + return s2; + } +} + +void port_clause() : {} +{ + <PORT_T> <LPAREN_T> port_list()<RPAREN_T> <SEMI_T>{ currP=0; } +} + +QCString port_list() : {QCString s;} +{ + s=interface_list(){return s;} +} + +void port_map_aspect() : {} +{ + <PORT_T> <MAP_T> <LPAREN_T> association_list() <RPAREN_T> +} + +QCString primary() : {QCString s,s1;} +{ +LOOKAHEAD(function_call()) +s=function_call() { return s;} +| +LOOKAHEAD(<LPAREN_T> expression() <RPAREN_T>) + <LPAREN_T> s1=expression() <RPAREN_T>{ s="("+s1+")"; return s;} +| +LOOKAHEAD(qualified_expression()) +s=qualified_expression() { return s;} +| +LOOKAHEAD(type_conversion()) +s=type_conversion() { return s;} +| +LOOKAHEAD(literal()) +s=literal() { s.prepend(" ");return s;} +| +LOOKAHEAD(name()) +s=name() { return s;} +| +allocator() { return "";} +| +s=aggregate() { return s; } +} + + +void primary_unit() : {} +{ +entity_declaration() +| configuration_declaration() +| +LOOKAHEAD(package_instantiation_declaration()) +package_instantiation_declaration() +| +LOOKAHEAD(4) + interface_package_declaration() +| package_declaration() + +} + +QCString procedure_call() : {QCString s,s1;} +{ + s=name() [ <LPAREN_T> s1=actual_parameter_part() <RPAREN_T>{ s1.prepend("("); s1.append(")");}] +{ return s+s1;} + } + +QCString procedure_call_statement() : {QCString s,s1;} +{ +[LOOKAHEAD(2) s=identifier() <COLON_T> { s+=":"; }] s1=procedure_call() <SEMI_T> +{ + return s+s1+";"; +} +} + +QCString process_declarative_item() : {QCString s;} +{ +subprogram_declaration() { return "";} +//| subprogram_body() +| s=type_declaration() { return s;} +| s=subtype_declaration() { return s;} +| s=constant_declaration() { return s;} +| s=variable_declaration() { return s;} +| s=file_declaration() { return s;} +| s=alias_declaration() { return s;} +| +LOOKAHEAD(3) +s=attribute_declaration() { return s;} +| s=attribute_specification() { return s;} +| s=use_clause() { return s;} +| +LOOKAHEAD(3) +s=group_template_declaration() { return s;} +| s=group_declaration() { return s;} +} + +QCString process_declarative_part() :{QCString s,s1;} +{ + ( s1=process_declarative_item(){s+=s1;} )* { return s;} +} + +void process_statement() : {QCString s,s1,s2;Token *tok=0;} +{ +[ s=identifier() <COLON_T> ] +[ <POSTPONED_T> ] + { + currP=VhdlDocGen::PROCESS; + current->startLine=getLine(); + current->bodyLine=getLine(); + } + <PROCESS_T> + try{ + [ <LPAREN_T> (tok=<ALL_T> | s1=sensitivity_list()) <RPAREN_T> ] [ <IS_T> ] + s2=process_declarative_part() + { + if (s2.data()) + FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s2.data(),0); + FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0); + } + <BEGIN_T> + process_statement_part() + <END_T> [ <POSTPONED_T> ] + }catch(...){error_skipto(PROCESS_T);} + <PROCESS_T> [ identifier() ] <SEMI_T> + { + if(s.isEmpty()) + currName=VhdlDocGen::getProcessNumber(); + else + currName=s; + + current->name=currName; + tempEntry=current; + current->endBodyLine=getLine(); + currP=0; + if(tok) + s1=tok->image.data(); + createFunction(currName,VhdlDocGen::PROCESS,s1.data()); + createFlow(); + currName=""; + newEntry(); +} +} + +void process_statement_part() : {} +{ + (sequential_statement())* +} + +QCString qualified_expression() : {QCString s,s1;} +{ + s1=identifier() <APOSTROPHE_T> {s=s1+"'";} + ( + LOOKAHEAD(aggregate()) + s1=aggregate(){s+=s1;} + | <LPAREN_T> s1=expression() <RPAREN_T>{s+="(";s+=s1;s+=")";} + ) + {return s;} +} + +QCString range() : {QCString s,s1,s2;} +{ + LOOKAHEAD( simple_expression() direction() simple_expression()) + s=simple_expression() s1=direction() s2=simple_expression(){return s+" "+s1+" "+s2;} + | + LOOKAHEAD(attribute_name()) + s=attribute_name(){ return s;} +} + +QCString range_constraint() : {QCString s,s1;} +{ +<RANGE_T> s=range(){return " range "+s;} +} + +void record_type_definition() : {} +{ + <RECORD_T> + try{ + (element_declaration())+ + }catch(...){error_skipto(END_T);} + <END_T> + <RECORD_T> [ name()] +} + +QCString relation() : {QCString s,s1,s2;} +{ + s=shift_expression() [LOOKAHEAD(1) s1=relation_operator() s2=shift_expression() ] {return s+s1+s2;} +} + +QCString relation_operator() : {} +{ + <LT_T> {return "<";} + |<GT_T> {return ">";} + |<EQU_T> {return "=";} + |<GREATERTHAN_T> {return ">=";} + |<LESSTHAN_T> {return "<=";} + |<NOTEQU_T> {return "/=";} + +} + +QCString report_statement() : {Token *t=0;Token *t1=0;QCString s,s1,s2;} +{ +[ s=identifier() t=<COLON_T> ] + <REPORT_T> s1=expression() + [ t1=<SEVERITY_T> s2=expression() ] <SEMI_T> + { + if(t) s.append(":"); + s1.prepend(" report "); + if(t1) s2.prepend(" severity "); + return s+s1+s2+";"; + } +} + +QCString return_statement() : {QCString s,s1;} +{ +[ s=identifier() <COLON_T> { s+=":";}] <RETURN_T> [ s1=expression() ] <SEMI_T> +{ return s+" return "+s1+";";} +} + +QCString scalar_type_definition() : {QCString s,s1;} +{ + +s=enumeration_type_definition(){ return s;} +| s=range_constraint() [LOOKAHEAD( physical_type_definition()) s1=physical_type_definition()] { s+=" ";s+=s1;return s;} +} + +void secondary_unit() : {} +{ +architecture_body() +| package_body() +} + +QCString secondary_unit_declaration() : {QCString s,s1;} +{ +s=identifier() <EQU_T> s1=physical_literal() <SEMI_T> { return s+"="+s1; } +} + +QCString selected_name() : {QCString s,s1;} +{ + s=identifier() <DOT_T> s1=suffix(){ return s+"."+s1;} +} + +void selected_signal_assignment() : {} +{ + <WITH_T> expression() <SELECT_T> + + target() < LESSTHAN_T> options() selected_waveforms() <SEMI_T> +} + +void selected_waveforms() : {} +{ + waveform() <WHEN_T> choices()(<COMMA_T> waveform() <WHEN_T> choices())* +} + +QCString sensitivity_clause() : {QCString s;} +{ + <ON_T> s=sensitivity_list() + { + s.prepend(" on "); + return s; + } +} + +QCString sensitivity_list() : {QCString s,s1;} +{ + s=name() (<COMMA_T> s1=name(){s+=",";s+=s1;} )* { return s;} +} + +void sequence_of_statement() : {} +{ + ( LOOKAHEAD(3)sequential_statement())* +} + +void sequential_statement() :{QCString s;} +{ + LOOKAHEAD( [ identifier() ":" ] target() "<=") + s=signal_assignment_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} + | + LOOKAHEAD(3) + s=assertion_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} + | + LOOKAHEAD(3) + s=report_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} + | + LOOKAHEAD(3) + s=wait_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} + | + LOOKAHEAD( [ identifier() ":" ] target() ":=" ) + s=variable_assignment_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} + | + LOOKAHEAD(3) + s=procedure_call_statement(){ FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0); } + | + LOOKAHEAD(3) + if_statement() + | + LOOKAHEAD(3) + case_statement() + | + LOOKAHEAD(3) + loop_statement() + | + LOOKAHEAD(3) + s=next_statement() + | + LOOKAHEAD(3) + s=exit_statement() + | + LOOKAHEAD(3) + s=return_statement(){FlowChart::addFlowChart(FlowChart::RETURN_NO,s.data(),0);} + | + s=null_statement(){FlowChart::addFlowChart(FlowChart::TEXT_NO,s.data(),0);} +} + +QCString shift_expression() : {QCString s,s1,s2;} +{ + s=simple_expression() [ s1=shift_operator() s2=simple_expression() ] { return s+s1+s2;} +} +QCString shift_operator() : {} +{ + <SLL_T> { return "sll";} + | <SRL_T> { return "srl";} + | <SLA_T> { return "sla";} + | <SRA_T> { return "sra";} + | <ROL_T> { return "rol";} + | <ROR_T> { return "ror";} +} + +QCString sign() : {} +{ + <PLUS_T> { return "+";} + | <MINUS_T> { return "-";} +} + +QCString signal_assignment_statement() : {QCString s,s1,s2,s3;} +{ + + LOOKAHEAD(conditional_signal_assignment_wave()) + conditional_signal_assignment_wave(){ return ""; } +| + LOOKAHEAD(selected_signal_assignment_wave()) + selected_signal_assignment_wave() { return ""; } + | + [LOOKAHEAD(2) s=identifier() <COLON_T> {s+=":";} ] +s1=target() <LESSTHAN_T> +[ s2=delay_mechanism() ] +s3=waveform() <SEMI_T> +{ + return s+s1+"<="+s2+s3+";"; +} + +} + +void semi() : {} +{ +<SEMI_T> +} + +void signal_declaration() : {QCString s,s1,s2,s3,s4;} +{ +<SIGNAL_T> s=identifier_list() <COLON_T> s1=subtype_indication() [ s2=signal_kind() ] [ <VARASSIGN_T> s3=expression() ] <SEMI_T> + { + s4=s1+s2+s3; + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SIGNAL,0,s4.data(),Public); + } +} +QCString signal_kind() : {} +{ + <REGISTER_T> { return "register";} + | <BUS_T> { return "bus";} +} + +QCString signal_list() : {QCString s,s1;} +{ + s=name() (<COMMA_T> s1=name() { s+=",";s+=s1;})* +| <OTHER_T> { return "other";} +| <ALL_T> { return "all";} +} + +QCString signature() : {QCString s,s1,s2;} +{ +<LBRACKET_T> + [ s=name() (<COMMA_T> s1=name() {s+=",";s+=s1; })* ] + [ <RETURN_T> s1=name() {s+="return ";s+=s1;}] + <RBRACKET_T> + { s1="["+s+"]";return s1;} + } + +QCString simple_expression(): {QCString s,s1,s2;} +{ +[ s=sign() ] s1=term() {s+=s1;} ( LOOKAHEAD(adding_operator()) s1=adding_operator() s2=term() {s+=s1;s+=s2;})* { return s;} +} + +void simple_name() : {} +{ +name() +} + +QCString slice_name() : {QCString s,s1;} +{ + s=identifier() <LPAREN_T> s1=discrete_range() <RPAREN_T> {return s+"("+s1+")";} +} + +QCString string_literal() : {Token *tok;} +{ +tok=<STRINGLITERAL> {return tok->image.c_str();} +} + + void subprogram_body() : {QCString s;} +{ +//subprogram_specification() +<IS_T> + try{ + s=subprogram_declarative_part() + { + if (s.data()) + { + FlowChart::addFlowChart(FlowChart::VARIABLE_NO,s,0); + } + FlowChart::addFlowChart(FlowChart::BEGIN_NO,"BEGIN",0); + } + }catch(...){error_skipto(BEGIN_T);} +<BEGIN_T> +subprogram_statement_part() +<END_T> [ subprogram_kind() ] [ designator() ] <SEMI_T> + { + tempEntry->endBodyLine=getLine(END_T); + createFlow(); + currP=0; + } +} + +void subprogram_declaration() : {} +{ +LOOKAHEAD(subprogram_instantiation_declaration()) +subprogram_instantiation_declaration() +| +subprogram_specification()subprogram_1(){currP=0;} +} + +void subprogram_1() : {} +{ + + subprogram_body() + | <SEMI_T> +} + +QCString subprogram_declarative_item() : {QCString s;} +{ +subprogram_declaration(){ return "";} +|s=type_declaration(){ return s;} + | subprogram_body(){ return "";} +| s=subtype_declaration(){ return s;} +| s=constant_declaration(){ return s;} +| s=variable_declaration(){ return s;} +| s=file_declaration(){ return s;} +| s=alias_declaration(){ return s;} +| +LOOKAHEAD(attribute_declaration()) +s=attribute_declaration(){ return s;} +| s=attribute_specification(){ return s;} +| s=use_clause(){ return s;} +| +LOOKAHEAD(3) +s=group_template_declaration(){ return s;} +| s=group_declaration() { return s;} +} + +QCString subprogram_declarative_part() : {QCString s,s1;} +{ + (s1=subprogram_declarative_item(){s+=s1;})* { return s;} +} + +void subprogram_kind() : {} +{ + <FUNCTION_T> + |<PROCEDURE_T> +} + +void subprogram_specification() : {QCString s;Token *tok=0;Token *t;} +{ + <PROCEDURE_T> s=designator() + { + currP=VhdlDocGen::PROCEDURE; + createFunction(s.data(),currP,0); + tempEntry=current; + current->startLine=getLine(PROCEDURE_T); + current->bodyLine=getLine(PROCEDURE_T); + + } [LOOKAHEAD(1) <LPAREN_T> { param_sec=PARAM_SEC; } interface_list() { param_sec=0; }<RPAREN_T> ] + [LOOKAHEAD(2) gen_interface_list()] + [ LOOKAHEAD(2) gen_assoc_list()] + param() + { newEntry(); } +| + [ (tok=<PURE_T> | tok=<IMPURE_T>) ] t=<FUNCTION_T> s=designator() + { + currP=VhdlDocGen::FUNCTION; + if(tok) + createFunction(tok->image.c_str(),currP,s.data()); + else + createFunction(0,currP,s.data()); + tempEntry=current; + current->startLine=getLine(FUNCTION_T); + current->bodyLine=getLine(FUNCTION_T); + } + [{ param_sec=PARAM_SEC; } <LPAREN_T> formal_parameter_list() <RPAREN_T> { param_sec=0; }] + <RETURN_T> s=type_mark() + { + tempEntry=current; + current->type=s; + newEntry(); + } +} + +void subprogram_statement_part() : {} +{ + (sequential_statement())* +} + +QCString subtype_declaration() : {QCString s,s1;} +{ +<SUBTYPE_T> s=identifier() <IS_T> s1=subtype_indication() <SEMI_T> + { + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::SUBTYPE,0,s1.data(),Public); + return " subtype "+s+" is "+s1+";"; + } +} + +QCString subtype_indication() : {QCString s,s1,s2;} +{ + s=name() + [LOOKAHEAD (name()) s1=name()] [LOOKAHEAD(constraint() ) s2=constraint()] + {return s+" "+s1+" "+s2;} +} + +QCString suffix() : {QCString s;} +{ +LOOKAHEAD(name()) +s=name() { return s;} +| s=character_literal() { return s;} +| s=operator_symbol(){ return s;} +| <ALL_T> {return " all ";} +} + +QCString target() : {QCString s;} +{ + s=name(){ return s;} +| s=aggregate() { return s;} +} + +QCString term() : {QCString s,s1,s2;} +{ + s=factor() ( LOOKAHEAD(2) s1=multiplying_operation() s2=factor(){s+=s1;s+=s2;} )* { return s;} +} + +QCString timeout_clause() : {QCString s;} +{ +<FOR_T> s=expression() +{ + return " for "+s; +} +} + +QCString type_conversion() : {QCString s,s1;} +{ + s=name() <LPAREN_T> s1=expression() <RPAREN_T> { return s+"("+s1+")";} +} + +QCString type_declaration() : {QCString s;} +{ +LOOKAHEAD(3) +s=full_type_declaration(){ return s;} +| s=incomplete_type_declaration(){ return s;} +} + +QCString type_definition() : {QCString s;} +{ +//try{ +s=scalar_type_definition(){ return s;} +| s=composite_type_definition(){ return s;} +| s=access_type_definition(){ return s;} +| s=file_type_definition(){ return s;} +| + LOOKAHEAD(2) + protected_type_body() { return ""; } +| protected_type_declaration() { return ""; } +//}catch(...){error_skipto(SEMI_T); return "";} +} + +QCString type_mark() : {QCString s; } +{ + s=name() { return s;} +} + +QCString unconstraint_array_definition() : {QCString s,s1,s2,s3;} +{ +<ARRAY_T> <LPAREN_T> s=index_subtype_definition() ( <COMMA_T> s1=index_subtype_definition(){s3+=",";s3+=s1;})* <RPAREN_T> + <OF_T> s2=subtype_indication() {return "array("+s+s3+") of "+s2;} +} + + QCString use_clause() : {QCString s,s1;} +{ + <USE_T> s=selected_name()(<COMMA_T> s1=selected_name(){s+=",";s+=s1;})* <SEMI_T> + { + QStringList ql1=QStringList::split(",",s,FALSE); + for (uint j=0;j<ql1.count();j++) + { + QCString it=ql1[j].utf8(); + if ( parse_sec==0 && Config_getBool("SHOW_INCLUDE_FILES") ) + { + ::vhdl::parser::VhdlParser::addVhdlType(it.data(),getLine(),Entry::VARIABLE_SEC,VhdlDocGen::USE,it.data(),"_use_",Public); + } + } + s1="use "+s; + return s1; + } +} + +QCString variable_assignment_statement() : {QCString s,s1,s2;} +{ +[LOOKAHEAD(2) s=identifier() <COLON_T> {s+=":";}] + s1=target() <VARASSIGN_T> s2=expression() <SEMI_T> + {return s+s1+":="+s2+";";} + | + selected_variable_assignment() { return ""; } +} + +QCString variable_declaration() : {Token *tok=0;QCString s,s1,s2;} +{ +[ tok=<SHARED_T> ] <VARIABLE_T> s=identifier_list() <COLON_T> s1=subtype_indication() +[ <VARASSIGN_T> s2=expression() ] <SEMI_T> + +{ + int spec; + QCString val=" variable "+s+":"+s1+":="+s2+";"; + QCString it=s1+" "+s2; + if(tok != 0) + { + it.prepend(" shared "); + val.prepend(" shared"); + spec=VhdlDocGen::SHAREDVARIABLE; + } + else + spec=VhdlDocGen::SHAREDVARIABLE; + + addVhdlType(s.data(),getLine(),Entry::VARIABLE_SEC,spec,0,it.data(),Public); + return val; + } + +} + +QCString wait_statement() : {QCString s,s1,s2,s3;Token *t=0;} +{ +[ s=identifier() <COLON_T> ] <WAIT_T> [ s1=sensitivity_clause() ] [ s2=condition_clause() ] [ s3=timeout_clause() ] <SEMI_T> +{ + if(t) s.append(":"); + return s+" wait "+s1+s2+s3+";"; +} +} + +QCString waveform() : {QCString s,s1;} +{ +s=waveform_element() (<COMMA_T> s1=waveform_element(){s+=","; s+=s1;})* { return s;} +| +<UNAFFECTED_T> { return " unaffected ";} + +} + +QCString waveform_element() : {QCString s,s1;} +{ + s=expression() [ <AFTER_T> s1=expression(){ s1.prepend(" after ");} ] + { return s+s1;} +//<NULL_T> [ <AFTER_T> expression() ] +} + +// ----------------------------------------------------------------- +// VHDL 2002 +// ----------------------------------------------------------------- + +QCString protected_type_body() :{ } +{ + try{ + <PROTECTED_T> <BODY_T> + protected_type_body_declarative_part() + + }catch(...){error_skipto(END_T);} + <END_T><PROTECTED_T> <BODY_T> [identifier()] {return "";} +} + +void protected_type_body_declarative_item() : { } + { + subprogram_declaration() + | subprogram_body() + | type_declaration() + | subtype_declaration() + | constant_declaration() + | variable_declaration() + | file_declaration() + | alias_declaration() + | + LOOKAHEAD( attribute_declaration()) + attribute_declaration() + | attribute_specification() + | use_clause() + | LOOKAHEAD(3) + group_template_declaration() + | group_declaration() + +} + +void protected_type_body_declarative_part() :{ } +{ + ( protected_type_body_declarative_item ())* +} + + +QCString protected_type_declaration() : { } + { + <PROTECTED_T> + try{ + protected_type_declarative_part() + }catch(...){error_skipto(END_T);} + <END_T><PROTECTED_T> [ identifier() ] { return "";} + } + + +void protected_type_declarative_item(): { } +{ + subprogram_specification() + | attribute_specification() + | use_clause() +} + +void protected_type_declarative_part() : {} +{ + (protected_type_declarative_item ()<SEMI_T>)* +} + +// ----------------------------------------------------------------- +// VHDL 2008 +// ----------------------------------------------------------------- + +QCString context_ref() : {QCString s;} +{ + <CONTEXT_T> s=identifier_list() <SEMI_T> + { + return "context "+s ; + } +} + + +void context_declaration(): {QCString s,s1;} +{ + <CONTEXT_T> s=identifier() <IS_T> { parse_sec=CONTEXT_SEC; } (s1=libustcont_stats())* <END_T> [ <CONTEXT_T> ][identifier()] <SEMI_T> + { + parse_sec=0; + addVhdlType(s.data(),getLine(LIBRARY_T),Entry::VARIABLE_SEC,VhdlDocGen::LIBRARY,"context",s1.data(),Public); + } +} + +QCString libustcont_stats(): {QCString s;} +{ + s=use_clause() { return s;} + | s=library_clause() { return s;} + | s=context_ref() { return s;} +} + + void package_instantiation_declaration() : {QCString s,s1,s2;} + { + <PACKAGE_T> s=identifier() <IS_T> <NEW_T> s1=name() s2=signature() [gen_assoc_list()] <SEMI_T> + { + QCString q=" is new "+s1+s2; + addVhdlType(s.data(),getLine(PACKAGE_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"package",q.data(),Public); + } +} + +QCString interface_package_declaration(): {QCString s,s1;} +{ + <PACKAGE_T> s=identifier() <IS_T> <NEW_T> s1=name() [gen_assoc_list()] + { + current->name=s; + return "package "+s+" is new "+s1; + } +} + +QCString subprogram_instantiation_declaration():{QCString s,s1,s2;} +{ + <FUNCTION_T> s=identifier() <IS_T> <NEW_T> s1=name() s2=signature() [gen_assoc_list()] <SEMI_T> + { + QCString q= " is new "+s1+s2; + addVhdlType(s.data(),getLine(FUNCTION_T),Entry::VARIABLE_SEC,VhdlDocGen::INSTANTIATION,"function ",q.data(),Public); + return q; + } +} + + +void gen_assoc_list():{} +{ + <GENERIC_T> <MAP_T> <LPAREN_T> association_list()<RPAREN_T> +} + +void gen_interface_list() : {} +{ + <GENERIC_T><LPAREN_T> + { + //int u=s_str.iLine; + parse_sec=GEN_SEC; + } + interface_list() + { + // QCString vo=$3; + parse_sec=0; + } + <RPAREN_T> +} + +void case_scheme (): {} +{ + <CASE_T> expression() <GENERATE_T> when_stats() [LOOKAHEAD(3) ttend()] <END_T> + <GENERATE_T> generate_statement_body() <SEMI_T> +} + +void when_stats() : {} +{ + ( + <WHEN_T> [LOOKAHEAD(2) label() <COLON_T>] choices() <ARROW_T> generate_statement_body() + )+ +} + + +void ttend(): {} +{ + <END_T> [identifier()] <SEMI_T> + } + + + +void generate_statement_body() : {} +{ + <BEGIN_T> [block_declarative_part() <BEGIN_T>] (concurrent_statement())* +} + +QCString external_name(): {QCString s,s1,s2;} +{ + <SLSL_T> s=sig_stat() s1=external_pathname() <COLON_T> s2=subtype_indication() <RSRS_T> + { + QCString t="<<"+s; + QCString t1=s1+":"+s2+">>"; + return s+s1; + } +} + +QCString sig_stat(): {Token *t;} +{ + t=<CONSTANT_T> { return t->image.data(); } + | t=<SIGNAL_T> { return t->image.data(); } + | t=<VARIABLE_T> { return t->image.data(); } + +} + +QCString external_pathname(): {QCString s;} +{ + s=absolute_pathname() { return s;} + | s=relative_pathname() { return s;} + | s=package_path_name() { return s;} + } + +QCString absolute_pathname(): {QCString s,s1;} +{ + LOOKAHEAD(<DOT_T> pathname_element_list()) + <DOT_T> s=pathname_element_list() s1=identifier() { return "."+s+s1;} +| <DOT_T> s=identifier (){ return "."+s;} +} + +QCString relative_pathname():{QCString s,s1,s2;} +{ + s=neg_list() [LOOKAHEAD( pathname_element_list()) s1=pathname_element_list() ] s2=identifier() { return s+s1+s2;} +} + +QCString neg_list(): {QCString s;} +{ + (<NEG_T> <DOT_T>{s+="^.";})+ {return s; } +} + +QCString pathname_element ():{QCString s,s1;} +{ + s=identifier() [<LPAREN_T> s1=expression() <RPAREN_T>] + { + if(!s1.isEmpty()) + return s+"("+s1+")"; + + return s; + } + } + +QCString pathname_element_list():{QCString s,s1,s2;} +{ + ( s=pathname_element() <DOT_T> ) {s+=".";} (LOOKAHEAD(pathname_element() <DOT_T>) s1=pathname_element() <DOT_T> {s2+=s1;s2+="."; })* + { return s+s2; } +} + +QCString package_path_name():{QCString s;} +{ + <AT_T> s=name() { return "@"+s; } +} + +void conditional_signal_assignment_wave(): {} +{ + LOOKAHEAD(conditional_force_assignment()) + conditional_force_assignment() + |conditional_waveform_assignment() +} + +void conditional_waveform_assignment():{} +{ + target() <LESSTHAN_T> [LOOKAHEAD(1) delay_mechanism() ] waveform_element() <WHEN_T> expression() [else_wave_list()] <SEMI_T> + } + +void else_wave_list(): {} +{ +<ELSE_T> expression() [ <WHEN_T> expression()] +} + +void conditional_force_assignment(): {} +{ + target() <LESSTHAN_T> <FORCE_T> [inout_stat()] expression() <WHEN_T> [expression() else_stat()] <SEMI_T> +} + +void selected_signal_assignment_wave() : {} +{ + LOOKAHEAD(selected_force_assignment() ) + selected_force_assignment() +| selected_waveform_assignment() +} + +void selected_variable_assignment():{} +{ + <WITH_T> expression() <SELECT_T> [<Q_T>] select_name() <VARASSIGN_T> sel_var_list() // { $$=""; } +} + +void select_name(): {} +{ + LOOKAHEAD(aggregate()) + aggregate() + | name() + +} + +void selected_waveform_assignment():{} +{ + <WITH_T> expression() <SELECT_T> [<Q_T>] + target() <LESSTHAN_T> [delay_mechanism()] sel_wave_list() +} + +void selected_force_assignment():{} +{ +<WITH_T> expression() <SELECT_T> [<Q_T>] target() <LESSTHAN_T> <FORCE_T> + [inout_stat()] sel_var_list() +} + +void sel_var_list(): {} +{ + (expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))(LOOKAHEAD(expression() <WHEN_T>) expression() <WHEN_T> choices() (<COMMA_T>|<SEMI_T>))* + +} + + +void sel_wave_list() : {} +{ + waveform_element() <WHEN_T> choices() (LOOKAHEAD(1) <COMMA_T> sel_wave_list())* <SEMI_T> + // | sel_wave_list_1() +} + + + +void inout_stat(): {} +{ + <IN_T> + | <OUT_T> + } + +void else_stat(): {} +{ + (<ELSE_T> expression() [LOOKAHEAD(1) <WHEN_T> expression()])+ +} + + + +QCString interface_subprogram_declaration(): {QCString s;} +{ + s=iproc() { return s;} + | s=ifunc() { return s; } +} + +QCString iproc(): {QCString s,s1;} + { + <PROCEDURE_T> s=identifier() s1=param() + { + current->name=s; + return "procedure "+s+s1; + } + } + +QCString ifunc():{QCString s,s1,s2,s3;Token *t=0;Token *t1=0;Token *t2=0;} +{ + + [t=<PURE_T> | t=<IMPURE_T> ] <FUNCTION_T> s=name() s1=param() <RETURN_T> s2=name() [t1=<IS_T> (s3=identifier() | t2=<BOX_T>)] + { + QCString q; + if(t) q=t->image.data(); + if(t2) s3="<>"; + if (!s3.isEmpty()) + { + s3.prepend(" is "); + } + current->name=s; + if (parse_sec==GEN_SEC) + { + QCString ss=q+" function "+s1+" return "+s2+s3; + int a=getLine(FUNCTION_T); + int b=getLine(PROCEDURE_T); + + if (a>b) b=a; + addVhdlType(current->name.data(),b,Entry::VARIABLE_SEC,VhdlDocGen::GENERIC,ss.data(),0,Public); + } + currP=0;return ""; + } + + } + + +QCString param(): {QCString s,s1;Token *tok=0;} +{ +[ tok=<PARAMETER_T> ] { param_sec=PARAM_SEC; } + [ <LPAREN_T> s1=interface_list() <RPAREN_T>] + { + if(tok) + { + s = tok->image.data(); + param_sec=0; + } + return s+"("+s1+")"; + } + + } + + // ----------------------------------------------------------------- + // needed for inline (function/process/procedure) parsing + +void parseInline() : {} +{ + process_statement() + | subprogram_declaration() + } |