/******************************************************************************

 *

 * 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="vhdljjparser.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(const char *n, const char* instName, const char* comp,int iLine);

static void handleCommentBlock(const char* doc,bool brief);

static void handleFlowComment(const char*);

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);

static void oneLineComment(QCString qcs);

static void setMultCommentLine();

PARSER_END(VhdlParser)

SKIP :

{

  " "

| "\t"

| "\n" {::vhdl::parser::VhdlParser::lineCount();}

| "\r"

}

SKIP:

{

  // VHDL comment -- ......

  // VHDL doxygen line comment --! ....

  <#DOXYGEN_VHDL_COMMENT: (" "|"\t")*"--!"(~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>

  | <MULT_DOXYGEN_COMMENT: (<DOXYGEN_VHDL_COMMENT>)+ >

  {

    {

    QCString doc(image.data());

    int count=doc.contains("--!");

    ::vhdl::parser::VhdlParser::setMultCommentLine();

    ::vhdl::parser::VhdlParser::lineCount(image.data());

    if (count == 1)

      ::vhdl::parser::VhdlParser::oneLineComment(doc);

    else

      ::vhdl::parser::VhdlParser::handleCommentBlock(image.data(),FALSE); ;

    }

  }

  |<VHDL_FLOWCHART_COMMENT: "--#" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>  { ::vhdl::parser::VhdlParser::handleFlowComment(image.data());}

  |<VHDL_COMMENT: "--" (~["\n", "\r"])* ("\n" | "\r" | "\r\n")?>

  {

    ::vhdl::parser::VhdlParser::lineCount(image.data());}

  }

// VHDL 2008  comment /* .... */

// VHDL 2008 doxygen comment /*! .... */

SKIP :

{

  <MULT_DOXYGEN_VHDL_COMMENT_2008 : "/*!"  (~[])* "*/" >

  {

   {

     QCString q(image.data());

     q.stripPrefix("/*!");

     q.resize(q.length()-2);

     ::vhdl::parser::VhdlParser::handleCommentBlock(q.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"> {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"> {VhdlParser::setLineParsed(COMPONENT_T);}

| <CASE_T: "case">

| <CONFIGURATION_T: "configuration"> {VhdlParser::setLineParsed(CONFIGURATION_T);}

| <CONSTANT_T: "constant">  {VhdlParser::setLineParsed(CONSTANT_T);}

| <CONTEXT_T: "context"> {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"> {VhdlParser::setLineParsed(END_T);}

| <ENTITY_T: "entity"> {VhdlParser::setLineParsed(ENTITY_T);}

| <EXIT_T: "exit">

| <FAIRNESS_T: "fairness">

| <FILE_T: "file"> {VhdlParser::setLineParsed(FILE_T);}

| <FOR_T: "for">

| <FORCE_T: "force">

| <FUNCTION_T: "function">  {VhdlParser::setLineParsed(FUNCTION_T);}

| <GENERATE_T: "generate">

| <GENERIC_T: "generic">

| <GROUP_T: "group"> {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"> {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: ";" >{::vhdl::parser::VhdlParser::setLineParsed(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>|<QUOTE>)["'"]) >

 | <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_OR_DIGIT_OR_STD: (<LETTER_OR_DIGIT> | <STD_LOGIC> ) >

 | < #LETTER: (<UPPER_CASE_LETTER>|<LOWER_CASE_LETTER>) >

 | < #UPPER_CASE_LETTER: ["A"-"Z"]  >

 | <BIT_STRING_LITERAL : (<DIGIT>)*<BASE_SPECIFIER>["\""](<LETTER_OR_DIGIT_OR_STD>((["_"])*<LETTER_OR_DIGIT_OR_STD>)*)["\""] >

 | <#BASE_SPECIFIER:["B","O","X","b","o","x","d","D"]>

 | <#STD_LOGIC:["0","1","L","H","X","Z","W","-","l","h","x","z","w"]>

 | < #DIGIT: ["0"-"9"] >

 | < #SPECIAL_CHARACTER: ["#","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","_","|"] >

 | < #OTHER_SPECIAL_CHARACTER: ["%","!","$","@","?","[","\\","]","^","`","{","}","~","\u00A0"-"\u00FF"]>

 | < #SPACE_CHARACTER: [" ","\t"] >

 | < #LOWER_CASE_LETTER: ["a"-"z"] >

 | < #QUOTE: ["\""] >

 | <VHDL2008TOOLDIR  : ["`"](<GRAPHIC_CHARACTER>|<STRINGLITERAL>)+ >

}

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=0;QCString str,str1;}

{

  tok=<ACCESS_T> str1=subtype_indication() { str=tok->image.c_str(); return str+str1; }

}

QCString actual_designator() :

{QCString str;Token *t=0;}

{

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() (<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() )*

 // | (<VHDL2008TOOLDIR>)

}

void architecture_statement_part() :  {}

{

  (concurrent_statement())*

 // | (<VHDL2008TOOLDIR>)

}

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() : {QCString s,s1;}

{

 [LOOKAHEAD(formal_part() <ARROW_T>) s=formal_part() <ARROW_T> ] s1=actual_part()

 { return s+" => "+s1;}

}

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=0;}

{

  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=0;}

{

  tok=<INTEGER> { return tok->image.c_str();}

}

QCString base_specifier ():  {Token *tok=0;}

{

   tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}

}

QCString base_unit_declaration() :

{QCString s;}

{

  s=identifier() { return s; }

}

QCString based_integer() :  {Token *tok=0;}

{

  tok=<BASIC_IDENTIFIER> { return tok->image.c_str();}

}

QCString based_literal():  {Token *tok=0;}

{

 tok=<BASED_LITERAL> { return tok->image.c_str();}

}

QCString basic_identifier() :  {Token *tok=0;}

{

  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=0;}

{

  tok=<BIT_STRING_LITERAL> { return tok->image.c_str();}

}

QCString bit_value() :  {Token *tok=0;}

{

  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()

//| <VHDL2008TOOLDIR>

}

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,"end case",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=0;}

{

  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; }

  |

  LOOKAHEAD(identifier())

  s=identifier(){ return s; }

  | <OTHER_T> { return " others "; }

}

QCString choices() :  {QCString s,s1;}

{

  s=choice() (<BAR_T> s1=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()

 {

       QCString s3;

       if (s1.contains("|")) {

         s3=VhdlDocGen::getIndexWord(s1.data(),0);

         s1=VhdlDocGen::getIndexWord(s1.data(),1);

       }

       addCompInst(s.lower().data(),s1.lower().data(),s3.data(),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()

| <VHDL2008TOOLDIR>

 /*

  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;}