/**
 * (C) 2002 Peter Kehl
 * peterk (@) paneris.org
 * version 1.00 Pukavik/Arava from 28th April 2002
 * Available at http://paneris.org/~peterk/vhdlams/
 *
 * Free under GNU GPL license version 2.
 * For more relaxations, contact Christoph Grimm and me.
 *
 * Container class Trans is separate and free for any use (BSD like).
 *
 * Based on:
 *
 * VHDL-93, VHDL-AMS grammar for JavaCC
 * (c) 1997 Christoph Grimm
 *
 * Email: grimm@ti.informatik.uni-frankfurt.de
 * Address:
 * Christoph Grimm
 * J. W. Goethe-University Frankfurt
 * Robert-Mayer-Strasse 11-15
 * 60054 Frankfurt
 * Germany
 */

/*
   Important notes for future development:
   1. Whole approach is described in Thesis, at same url as noted above.
   2. Read documentation of container class Trans.
   3. Editor with syntax C++/Java highlighting is a must.
   4. HTML BNF documentation fits for fast orientation in PDF/printed VHDL-AMS LRM.
   5. BNF productions with descriptive value were transformed - merged/skipped.
      They are commented in way: // new_production() was original_production().
   6. Generated C++ code is case sensitive. All VHDL-AMS tokens
      are transformed to lowercase. Names of additional structures, not visible
      to VHDL-AMS user, as matlabInterface, consist of uppercase characters.
*/

options
{
  DEBUG_PARSER = true;
  // CHOICE_AMBIGUITY_CHECK=3;
  IGNORE_CASE=false;
  STATIC = true;
  OPTIMIZE_TOKEN_MANAGER = true;
  CACHE_TOKENS = true;
}


// The parser is instanciated in the file Vhdl.java
PARSER_BEGIN(VhdlParser)

import java.util.*;
import java.io.*;

public class VhdlParser
{
  static ErrorHandler errs = new ErrorHandler();
  static final Trans noTrans= new Trans( " noTrans! ");
  static final String noTransStr= noTrans.toString();
  static final Trans unfinished= new Trans( " UNFINISHED! ");
  static final Trans empty= new Trans();
  static final Port noPort= new Port( "", "", new Trans(" NoPORT! ") );
  static final ArrayList noList= new ArrayList(); //!= freeList !!

  // Those lists are reset in library_unit().
  // They carry respective collected identifiers, used in architecture_body(). 
  static HashSet dots= new HashSet();
  static ArrayList generics= new ArrayList(), ports= new ArrayList(),
         quantities= new ArrayList(), components= new ArrayList();

  // Parsed data and flag whether actual production is called [indirectly]
  // from subtype_indication(). Used by interface_quantity_declaration(To),
  // name(), name_extension() and subtype_indication():
  static Trans typeParameters= noTrans;
  static boolean inSubtypeIndication= false;

  // Methods used for report and debugging only:
  static void ShowRes(String ent) {
       Entity entt= Entity.read( ent);
       System.out.println( "SHOWRES(): GENERICS OF ENTITY "+ent+":");
      for( int t=0; t<entt.generics.size(); t++) {
         System.err.println( "TYPE: " +entt.generic(t).type );
         System.err.println( "NAME: " +entt.generic(t).name );
      }
  }

  static void ShowComponents() {
     System.out.println( "KNOWN COMPONENTS:");
     for( int i=0; i<components.size(); i++) {
        Component c= (Component) components.get( i);
        System.out.println( "  COMPONENT " +c.label.toString() +" IS ENT " +c.unit.name +" ARCH " +c.unit.type);
        System.out.println( "  HAS GENERICS:" );
        for( int j=0; j<c.generics.size(); j++) {
           Port p= c.generic( j);
           System.out.println( p.type +" " +p.name);
        }
        System.out.println( "  HAS PORTS:" );
        for( int j=0; j<c.ports.size(); j++) {
           Port p= c.port( j);
           System.out.println( p.type +" " +p.name);
        }
     }//for i
     System.out.println( "END OF COMPONENTS" );
  }//ShowComponents
}

PARSER_END(VhdlParser)

SKIP :
{
    " "
  | "\n"
  | "\r"
  | "\t"
}

SPECIAL_TOKEN :
{
  <COMMENT: "--" (~["\n" , "\r"])* ("\n" | "\r" | "\r\n")>
}

// Section 13: Lexical elements with extensions from IEEE 1076.1

TOKEN [IGNORE_CASE] :
{
    <ABS:          "abs">
  | <ACCESS:       "access">
  | <ACROSS:       "across">
  | <AFTER:        "after">
  | <ALIAS:        "alias">
  | <ALL:          "all">
  | <AND:          "and">
  | <ARCHITECTURE: "architecture">
  | <ARRAY:        "array">
  | <ASSERT:       "assert">
  | <ATTRIBUTE:    "attribute">
  | <BEGIN:        "begin">
  | <BLOCK:        "block">
  | <BODY:         "body">
  | <BREAK:        "break">
  | <BUFFER:       "buffer">
  | <BUS:          "bus">
  | <CASE:         "case">
  | <COMPONENT:    "component">
  | <CONFIGURATION: "configuration">
  | <CONSTANT:      "constant">
  | <DISCONNECT:    "disconnect">
  | <DOWNTO:        "downto">
  | <ELSE:          "else">
  | <ELSIF:         "elsif">
  | <END:           "end">
  | <ENTITY:        "entity">
  | <EXIT:          "exit">
  | <FILE:          "file">
  | <FOR:           "for">
  | <FUNCTION:      "function">
  | <GENERATE:      "generate">
  | <GENERIC:       "generic">
  | <GROUP:         "group">
  | <GUARDED:       "guarded">
  | <IF:            "if">
  | <IMPURE:        "impure">
  | <IN:            "in">
  | <INERTIAL:      "inertial">
  | <INOUT:         "inout">
  | <IS:            "is">
  | <LABEL:         "label">
  | <LIBRARY:       "library">
  | <LINKAGE:       "linkage">
  | <LITERAL:       "literal">
  | <LOOP:          "loop">
  | <MAP:           "map">
  | <MOD:           "mod">
  | <NAND:          "nand">
  | <NATURE:        "nature">
  | <NEW:           "new">
  | <NEXT:          "next">
  | <NOISE:         "noise">
  | <NOR:           "nor">
  | <NOT:           "not">
  | <NULL:          "null">
  | <OF:            "of">
  | <ON:            "on">
  | <OPEN:          "open">
  | <OR:            "or">
  | <OTHERS:        "others">
  | <OUT:           "out">
  | <PACKAGE:       "package">
  | <PORT:          "port">
  | <POSTPONED:     "postponed">
  | <PROCEDURAL:    "procedural">
  | <PROCEDURE:     "procedure">
  | <PROCESS:       "process">
  | <PURE:          "pure">
  | <QUANTITY:      "quantity">
  | <RANGE:         "range">
  | <RECORD:        "record">
  | <REGISTER:      "register">
  | <REJECT:        "reject">
  | <REM:           "rem">
  | <REPORT:        "report">
  | <RETURN:        "return">
  | <ROL:           "rol">
  | <ROR:           "ror">
  | <SELECT:        "select">
  | <SEVERITY:      "severity">
  | <SIGNAL:        "signal">
  | <SHARED:        "shared">
  | <SLA:           "sla">
  | <SLL:           "sll">
  | <SPECTRUM:      "spectrum">
  | <SRA:           "sra">
  | <SRL:           "srl">
  | <SUBNATURE:     "subnature">
  | <SUBTYPE:       "subtype">
  | <TERMINAL:      "terminal">
  | <THEN:          "then">
  | <THROUGH:       "through">
  | <TO:            "to">
  | <TOLERANCE:     "tolerance">
  | <TRANSPORT:     "transport">
  | <TYPE:          "type">
  | <UNAFFECTED:    "unaffected">
  | <UNITS:         "units">
  | <UNTIL:         "until">
  | <USE:           "use">
  | <VARIABLE:      "variable">
  | <WAIT:          "wait">
  | <WHEN:          "when">
  | <WHILE:         "while">
  | <WITH:          "with">
  | <XNOR:          "xnor">
  | <XOR:           "xor">
}

TOKEN :
{
    <#upper_case_letter:               [ "A" - "Z" ]   >
  | <#lower_case_letter:               [ "a" - "z" ]   >

  | <#digit:                           [ "0" - "9" ]   >
  | <#extended_digit:                  [ "0" - "9" , "A" - "F" ]   >
  | <#special_character:               [ "#" , "&" , "'" , "(" , ")" , "*" , "+" , "," , "-" ,
                                        "." , "/" , ":" , ";" , "<" , "=" , ">" , "[" , "]" ,
                                        "_" , "|" ]   >
  | <#other_special_character:         [ "!" , "$" , "%" , "@" , "?" , "^" , "`" , "{" , "}" , "~" ,
                                        "\\" ]   >
  | <#format_effector:                 [ "\n" , "\t" ]   >
  | <#base_specifier:                  [ "B" , "O" , "X" ]   >
  | <#underline:                       "_"   >
  | <#letter:                          [ "a" - "z" , "A" - "Z" ]   >
  | <#letter_or_digit:                 [ "a" - "z" , "A" - "Z" , "0" - "9" ]   >
  | <#integer: <digit> ( ("_")? <digit> )*   >
  | <#base: <integer>  >
  | <#based_integer: ( ("_")? <extended_digit> )*   >
  | <based_literal: <base> "#" <based_integer> ( "." <based_integer> )? "#" (<exponent>)?   >
  | <#basic_character: (<basic_graphic_character> | <format_effector> )   >
  | <#basic_graphic_character: ( ["A"-"Z"] | <digit> | <special_character> | " " )   >
  | <basic_identifier: <letter> ( ("_")? <letter_or_digit> )*   >
  | <bit_string_literal: <base_specifier> "\"" <bit_value> "\""  >
  | <#bit_value: <extended_digit> ( ("_")? <extended_digit> )*   >
  | <character_literal:  "'" <graphic_character> "'"   >
  | <decimal_literal: <integer> ( "." <integer>)? ( <exponent> )?   >
  | <#exponent: ("E" ("+")? <integer>) | ("E" "-" <integer>)   >
  | <extended_identifier: "\\" <graphic_character> ( <graphic_character> )* "\\"   >
  | <#graphic_character: (<basic_graphic_character>
                          | <lower_case_letter>
                          | <other_special_character>)   >
  | <string_literal: "\"" (<graphic_character> | "\"\"" )* "\""   >

  | <EXP: "**"   >
  | <MUL: "*"   >
  | <DIV: "/"   >
  | <ADD: "+"   >
  | <SUB: "-"   >
  | <CONCAT: "&"   >
  | <EQ:  "="   >
  | <NEQ: "/="   >
  | <GE:  ">="   >
  | <LE:  "<="   >
  | <GT:  ">"   >
  | <LO:  "<"   >
  | <SEMICOLON: ";"   >
}

Trans abstract_literal() :
{Token t;}
{
    t= <decimal_literal> {return (new Trans( 0) ).conc( t ); }
  | t= <based_literal> {return (new Trans( 0) ).conc( t ); }
}

void access_type_definition() :
{}
{
  <ACCESS> subtype_indication()
}

Trans actual_designator() :
{Trans ret; }
{
    LOOKAHEAD(expression())
    ret=expression() {return ret; }
  | LOOKAHEAD(name())
    ret=name() {return ret; }
  | <OPEN> {return new Trans(0).conc( "OPEN" ); } // OPEN is not implemented
}

Trans actual_part() :
{Trans ret, add;}
{
    LOOKAHEAD( name() "(" actual_designator() ")")
    ret=name() "(" add=actual_designator() ")"
    {return ret.conc( "(" ).conc( add ).conc( ")" ); }

  | LOOKAHEAD( name() "(" actual_designator() ")") // name() was type_mark()
    ret=name() "(" add=actual_designator() ")"     // name() was type_mark()
    {return ret.conc( "(" ).conc( add ).conc( ")" ); }

  | ret=actual_designator()
    {return ret; }
}

Trans adding_operator() :
{}
{
    <ADD>               { return new Trans(0).conc( "+" ); }
  | <SUB>               { return new Trans(0).conc( "-" ); }
  | <CONCAT>            { return new Trans(0).conc( "+" ); } // For future String type.
}

// Implemented for vector literals only. See Thesis for more.
Trans aggregate() :
{Trans elem, ret= new Trans(0); int num=1; }
{
  "(" elem= element_association() {ret.conc( elem ); } // First item.

   ( "," elem= element_association()
       {
        if( num==1)
            ret.conc( ")" ); // Closing parenthesis to "VeCt( num, first)". See down.
        ret.conc( "," ).conc( elem ); // C++ comma operator adds items to VeCtor.
        num++;
       }
   )*

  ")"

  {
   if( num>1) ret.preconc( "VeCt(" +num +"," ); // Opening parenthesis and vector size.
   // Outer enclosing () pair is used, because C++ operator comma has low precedence.
   return ret.preconc( "(" ).conc( ")" );
  }
}


void alias_declaration() :
{}
{
  <ALIAS> alias_designator()
   [ ":" subtype_indication() ] <IS> name() signature() ";"
}

void alias_designator() :
{}
{
    identifier()
  | <character_literal>
  | operator_symbol()
}

Trans allocator() :
{Trans ret;}
{
  <NEW>
  (
      LOOKAHEAD( name() "'") // name() was type_mark()
      qualified_expression()
    | subtype_indication()
  )
  {return unfinished;}
}

// Reservated Trans containers are used there, see Trans doc for more.
// quantities, dots are global lists of collecte identifiers, see beginning of this file.
Trans architecture_body() :
{Trans ret= new Trans(0), stat, entity, arch, end= noTrans;}
{
  <ARCHITECTURE> arch= identifier() <OF> entity= identifier() <IS>
    architecture_declarative_part()
  <BEGIN>
    stat= architecture_statement_part()
  <END> [ <ARCHITECTURE> ] [ end= identifier() ] ";"

  {
  	if( end!=noTrans && !arch.equals( end))
		errs.Error( "ARCHITECTURE BEGIN & END IDENTIFIERS DON'T MATCH: "+
         arch+ "/="+ end);

   try {
      Entity ent= Entity.read( entity.toString() +".ent" );
      ports= ent.ports;

      ret.add( "#ifndef " +entity+arch +"_H" );
      ret.add( "#define " +entity+arch +"_H" );
      ret.newLine();

      // Structure that represents architecture:
      ret.add( "struct " ).conc( entity ).conc( arch ).conc( " {" );

      // Quantities and generics translated to member variables of C++ struct:
      ret.add( "// " ).conc( quantities.size() ).conc( " quantity(ies):" );
      for( int i=0; i<quantities.size(); i++) {
         Port q= (Port) quantities.get(i);
         ret.add( q.type +" " +q.name +";" );
      }

      ret.add( "// " ).conc( ent.generics.size() ).conc( " generic(s):" );
      for( int i=0; i<ent.generics.size(); i++) {
         Port q=  ent.generic( i);
         ret.add( q.type +" " +q.name +";" );
      }

      ArrayList compo= new ArrayList();

      // Definition of entity components:
      for( int i=0; i<components.size(); i++) {
         Component c= (Component)components.get( i);
         Entity e= Entity.read( c.unit.name +".ent");

         // c.unit is identification pair of architecture. TODO separate class for it.
         // [name == entity, type == architecture]
         Architecture a= Architecture.read( c.unit.name +c.unit.type +".arc");

         // Mapping ports of component:
         Trans ports= new Trans(0);
         // Reservated translation of component's actual ports. Filled below.
         Trans generics= new Trans(0); // Reservated
         compo.add( new Compo( c, e, generics, ports) );

         boolean formal= false;
         for( int j=0; j<c.ports.size(); j++) {
            String name= c.port(j).name; //formal port
            String actual= "";
            int k= j; // For a.dots used below - I remember formal port index.

            if( name==null || name.equals("") || name.equals(noTransStr) ) {
               if( formal)
                  System.err.println( "UNCONNECTED "+String.valueOf(j+1)+
                  ". PORT OF COMPONENT "+c.label.toString() );
               actual= c.port(j).type;
            }
            else {
               formal= true;
               for( k=0; k<e.ports.size(); k++)  //actual
                  if( e.port(k).name.equals(name) ) {
                     actual= c.port(k).type;
                     break;
                  }
               if(  k==c.ports.size() )
                  System.err.println( "BAD CONNECTED "+String.valueOf(j+1)+
                  ". PORT OF COMPONENT "+c.label.toString() );
            }

            ports.conc( actual ).conc( j!=c.ports.size()-1 ? ", " : "" );

            // DOTed ports of instantiated architecture(entity) are added to
            // DOTs of actually translated architecture, used below.
            if( a.dots.contains( e.port(k).name ) )
               dots.add( actual);
         } //for j
         if( c.ports.size()!=e.ports.size() )
            System.err.println( "BAD NUMBER OF COMPONENT PORTS "+c.label.toString() );

         // Mapping generics of component:
         formal= false;
         for( int j=0; j<c.generics.size(); j++) {
            String name= c.generic(j).name; //formal port
            String actual= "";
            int k= j;
            if( name==null || name.equals("") || name.equals(noTransStr) ) {
               if( formal)
                  System.err.println( "UNCONNECTED "+String.valueOf(j+1)+
                  ". GENERIC OF COMPONENT " +c.label.toString() );
               actual= c.generic(j).type;
            }
            else {
               formal= true;
               for( k=0; k<e.generics.size(); k++)  //actual
                  if( e.generic(k).name.equals(name) ) {
                     actual= c.generic(k).type;
                     break;
                  }
               if(  k==c.generics.size() )
                  System.err.println( "BAD CONNECTED "+String.valueOf(j+1)+
                  ". GENERIC OF COMPONENT " +c.label.toString() );
            }

            generics.conc( actual ).conc( j!=c.generics.size()-1 ? ", " : "" );
         } //for j

         if( c.generics.size()>e.generics.size() )
            System.err.println( "INSTANTIATED COMPONENT " +c.label.toString() +
               "HAS MORE GENERICS THAN IT SHOULD HAVE.");
         if( c.generics.size()<e.generics.size() ) {
            generics.conc( c.generics.size()>0 ? ", " : "" );
            for( int j=c.generics.size(); j<e.generics.size(); j++) {
               String opt= e.generic(j).optional;
               if( opt==null || opt.equals( "") || opt.equals( noTransStr) )
                  System.err.println( "UNCONNECTED GENERIC " +e.generic(j).name +
                     "OF COMPONENT " +c.label.toString() +
                     "DOESN'T HAVE DEFAULT VALUE.");
               else
                  generics.conc( opt ).conc( e.generics.size()-1>j ? ", " : "" );
            } //for j
         } //if
      } //for i

      ret.add( "// " ).conc( compo.size() ).conc( " component(s):" );
      for( int i=0; i<compo.size(); i++) {
         Compo co= (Compo) compo.get(i);
         ret.add( co.component.unit.name+co.component.unit.type ).conc(
            " " ).conc( co.component.label ).conc( ";" );
      }

      // DOT- derivation management part..."
      HashSet deriv_qs= new HashSet(); // integrated internal quantities
      HashSet deriv_ps= new HashSet(); // integrated port outputs

      for( int i=0; i<quantities.size(); i++) { // internal quantities have priority to ports
         String q= ( (Port)quantities.get( i) ).name;
        if( dots.contains( q)) {
            deriv_qs.add( q);
            dots.remove( q);
         }
      }

      for( int i=0; i<ports.size(); i++) {
         String q= ( (Port)ports.get( i) ).name;
         if( dots.contains( q)) {
            deriv_ps.add( q);
            dots.remove( q);
         }
      }

      if( dots.size()>0 ) {
         System.err.println( "UNKNOWN QUANTITY(IES) USING DOT:");
         for( Iterator it= dots.iterator(); it.hasNext(); )
           System.err.println( it.next() );
      }

      Architecture arch_file= new Architecture( deriv_ps);
      arch_file.write( entity.toString() +arch+ ".arc");

      // Constructor of structure
      ret.newLine();
      ret.add( "//Constructor of structure" );
      ret.add( entity ).conc( arch ).conc( "(" );
      for( int i=0; i<ent.generics.size(); i++) { // constructor arguments = generics
         Port g= ent.generic( i);
         ret.conc( " " ).conc( g.trans );
         ret.conc( i!=ent.generics.size()-1 ? "," : "" );
      }
      ret.conc( ")" );

      boolean used= false; // true if any constructor of fields was used already

      // First, constructors of generics go
      for( int i=0; i<ent.generics.size(); i++) {
         Port q= (Port) ent.generic( i);
         if( !used) {
            ret.conc( ": ");
            used= true;
         }
         else ret.conc( ", " );
         ret.conc( q.name ).conc( "(" ).conc( q.name ).conc( ")" );
      }

      // Constructors of quantities that have default (start) values
      for( int i=0; i<quantities.size(); i++) {
         Port q= (Port) quantities.get( i);
         if( !q.optional.equals("") ) {
            if( !used) {
               ret.conc( ": ");
               used= true;
            }
            else ret.conc( ", " );
            ret.conc( q.name ).conc( "(" ).conc( q.optional ).conc( ")" );
         }
      }

      // Components just same done as above
      for( int i=0; i<compo.size(); i++) {
          Compo co= (Compo)compo.get( i);
          if( co.entity.generics.size()>0) {
            if( !used) {
               ret.conc( ": ");
               used= true;
            }
            else ret.conc( ", " );
            ret.conc( co.component.label ).conc( "(" ).conc(
               co.generics ).conc( ")" );
         }
      }

      // Entity constructor body
      ret.conc( "{" );
      for( Iterator it=deriv_qs.iterator(); it.hasNext();) {
         ret.add( it.next() );
         ret.conc( ".integrated();" ); // Register integrated quantities
      }
      ret.add( "} //end of " ).conc( entity ).conc( arch ).conc( "()" );
      // Constructor end

      // go( ports... ) performs behaviour of architecture and components
      ret.newLine();
      ret.add( "//structure's go(..) does all processing:" );
      ret.add( "void go(" );
      for( int i=0; i<ent.ports.size(); i++) {
         Port p= ent.port( i);
         ret.conc( " " ).conc( p.trans );
         ret.conc( i!=ent.ports.size()-1 ? "," : "" );
      }

      ret.conc( ") {" );
      // Body of go(...)
      for( int i=0; i<compo.size(); i++) {
         Compo co= (Compo)compo.get( i);
         ret.add( "   ").conc( co.component.label ).conc( ".go( " ).conc(
            co.ports ).conc( ");" );
      }
      ret.add( stat);
      ret.add( "} //end of go()" );
      ret.newLine();
      ret.add( "}; //end of struct" );
      ret.add( "#endif" );

      // Add #include for header files of components
      for( Iterator it=components.iterator(); it.hasNext();) {
         Component c= (Component)it.next();
         ret.preadd( "#include \"" +c.unit.name+c.unit.type +".h\"" );
      }
      ret.preadd( "#include \"vector.h\"" );
      ret.preadd( "#include \"real.h\"" );

      try {
         ret.writeFile( entity.toString() +arch +".h");
      }
      catch(Exception e) {
         System.err.println( "ERROR GENERATING FILE "+entity.toString()+arch+".h");
      }

      // Make report to user
      try {
         System.out.println( "ARCHITECTURE "+ arch+ " PROCESSED" );
         System.out.println( " DOTs: ");
         Iterator it= dots.iterator();
         for( int i=0; i<dots.size(); i++)
            System.out.println( it.next().toString() );
         System.out.println( " INTERNAL QUANTITIEs: ");
         it= quantities.iterator();
         for( int i=0; i<quantities.size(); i++)
            System.out.println( it.next().toString() );
         System.out.println( " COMPONENTs: ");
         it= components.iterator();
         for( int i=0; i<components.size(); i++) {
            Component co= (Component)it.next();
            System.out.println( co.label.toString() +" ent: " +co.unit.name +
               " arch: " +co.unit.type );
         }
         System.out.println();
      }
      catch( Exception e) { System.err.println( "ERROR WHEN MAKING ARCHITECTURE REPORT"); }

      return ret;
   }
   catch( NullPointerException e)
      { return new Trans( "ERROR IN ARCHITECTURE BODY"); }
  }
}


void architecture_declarative_part() :
{}
{
  ( block_declarative_item() )*
}

Trans architecture_statement_part() :
{Trans hlp, ret= new Trans();}
{
  ( hlp= architecture_statement()
  {
  	ret.add( hlp);
  } )*

  {
  	return ret;
  }
}

// This rule also contains the concurrent statements.
Trans architecture_statement() :
{Trans ret;}
{
  // lookahead would really be annoying here. Therefore I have
  // moved the concurrent statement into this rule.
  // concurrent_statements:

  try {

    LOOKAHEAD([identifier() ":"] <BLOCK>)  // identifier() was block_label()
    block_statement() {return new Trans( "UNFINISHED BLOCK_STATEMENT!"); }
  | LOOKAHEAD([identifier() ":"] [<POSTPONED>] <PROCESS>)
    process_statement() {return new Trans( "UNFINISHED PROCESS_STATEMENT!"); }
  | LOOKAHEAD([identifier() ":"] [<POSTPONED>] procedure_call() ";")  // identifier() was label()
    concurrent_procedure_call_statement() {return new Trans( "UNFINISHED CONCURRENT PROCEDURE_CALL!"); }
  | LOOKAHEAD([identifier() ":"] [<POSTPONED>] <ASSERT>)  // identifier() was label()
  // assertion() was concurrent_assertion_statement(); 2nd identifier() was label()
    [ identifier() ":" ] [ <POSTPONED> ] assertion() ";" {return new Trans( "UNFINISHED ASSERTION") ;}
  | LOOKAHEAD([identifier() ":"] [<POSTPONED>] conditional_signal_assignment()|  // identifier() was label()
              [identifier() ":"] [<POSTPONED>] selected_signal_assignment())  // identifier() was label()
    concurrent_signal_assignment_statement() {return new Trans( "UNFINISHED SIGNAL ASSIGNMENT STATEMENT"); }
  | LOOKAHEAD(identifier() ":" instantiated_unit() )
    // Collects component info. Translated in architecture_body()
    component_instantiation_statement() {return empty;}
  | LOOKAHEAD(generate_statement())
    ret= generate_statement() {return ret; }

  /** 1076.1 extensions: */
  | LOOKAHEAD(concurrent_break_statement())
    ret= concurrent_break_statement() {return ret;}
  | ret= simultaneous_statement() {return ret;}

  }

  /** Error handling: Skip until next semicolon */
  catch(ParseException e)
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN STATEMENT");
  }
}


/**
 * 1076.1 extension:
 */
void array_nature_definition() :
{}
{
    LOOKAHEAD(<ARRAY> "(" index_subtype_definition() )
    unconstrained_nature_definition()
  | constrained_nature_definition()
}

/**
  * 1076.1 extension:
  */
void unconstrained_nature_definition() :
{}
{
  <ARRAY> "(" index_subtype_definition() ("," index_subtype_definition())* ")"
  <OF> subnature_indication()
}

/**
  * 1076.1 extension:
  */
void constrained_nature_definition() :
{}
{
  <ARRAY> index_constraint() <OF> subnature_indication()
}


void array_type_definition() :
{}
{
    LOOKAHEAD(unconstrained_array_definition())
    unconstrained_array_definition()
  | constrained_array_definition()
}

void assertion() :
{}
{
  <ASSERT> expression()  // exp=condition
  [ <REPORT> expression() ]
  [ <SEVERITY> expression() ]
}


void assertion_statement() :
{}
{
  [ identifier() ":" ] assertion() ";"  // ident=label
}



Port association_element() :
{Trans formal=noTrans, actual;}
{
  [ LOOKAHEAD( formal_part() "=>" ) formal=formal_part() "=>" ]
  actual=actual_part()
  {return new Port( formal.toString(), actual.toString(), noTrans); }
}

ArrayList association_list() :
{ArrayList ret=new ArrayList();
 Port elem;
}
{
  elem=association_element() {ret.add( elem); }
  (
    "," elem=association_element()  {ret.add( elem); }
  )*
  {return ret; }
}


void attribute_declaration() :
{}
{
  <ATTRIBUTE> identifier() ":" identifier() ";" // 2nd identifier() was type()
}

void attribute_name() :
{}
{
  prefix() signature() "'" attribute_simple_name() [ "(" expression() ("," expression())* ")" ]
  // attribute_simp_name() was attribute_designator()
}


void attribute_specification() :
{}
{
  <ATTRIBUTE> attribute_simple_name() <OF>
  // attribute_simp_name() was attribute_designator()
  entity_specification() <IS> expression() ";"
}


void binding_indication() :
{}
{
  [ <USE> entity_aspect() ]
  [ generic_map_aspect() ]
  [ port_map_aspect() ]
}

void block_configuration() :
{}
{
  <FOR> block_specification()
                ( use_clause() )*
                ( configuration_item() )*
  <END> <FOR> ";"
}

void block_declarative_item() :
{}
{
  try {

    LOOKAHEAD(subprogram_declaration())
    subprogram_declaration()
  | subprogram_body()
  | type_declaration()
  | subtype_declaration()
  | constant_declaration()
  | signal_declaration()
  | shared_variable_declaration()
  | file_declaration()
  | alias_declaration()
  | component_declaration()
  | LOOKAHEAD(attribute_declaration())
    attribute_declaration()
  | attribute_specification()
  | configuration_specification()
  | disconnection_specification()
  | use_clause()
  | LOOKAHEAD(<GROUP> identifier() <IS>)
    group_template_declaration()
  | group_declaration()

  /** 1076.1 - Extensions: */
  | nature_declaration()
  | subnature_declaration()
  | quantity_declaration( quantities)
  | terminal_declaration()

  }

  // Error handling: skip until next semicolon
  catch (ParseException e)
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATIVE ITEM");
  }
}


void block_declarative_part() :
{}
{
  ( block_declarative_item() )*
}

void block_header() :
{}
{
  [ generic_clause()  [ generic_map_aspect() ";" ] ]
  [ port_clause()     [ port_map_aspect() ";"    ] ]
}

void block_specification() :
{}
{
    LOOKAHEAD(name())
    name()
  | LOOKAHEAD(identifier()) // identifier() was block_statement_label()
    identifier()
  | LOOKAHEAD(identifier()) // identifier() was generate_statement_label()
    identifier() [ "(" index_specification() ")" ]
}


void block_statement() :
{}
{
  identifier() ":"  // identifier() was block_label()
                <BLOCK> [ "(" expression() ")" ] [ <IS> ]
                        block_header()
                        block_declarative_part()
                <BEGIN>
                        block_statement_part()
                <END> <BLOCK> [ identifier() ] ";" // identifier() was block_label()
}


void block_statement_part() :
{}
{
  (architecture_statement() )*
}


// Section 8.14: Break statement 1076.1 extension:
void break_statement() :
{}
{
  [identifier()  ":"] <BREAK> [break_list()] [<WHEN> expression() ] ";"
  //  identifier() was label(); expression() was condition()
}

// 1076.1 extension:
Trans break_list() :
{Trans ret= new Trans(), item;}
{
  item=break_element()
  {ret.add( item );}

  // Sourrounding {} are added up, when go() function is generated
  (
    ","
    item=break_element()
    {ret.add( item );}
  )*

  {return ret;}
}

// 1076.1 extension:
Trans break_element() :
{Trans target, value;}
{
  [ <FOR> name() <USE> ] // name() was selector_clause(), not used by us

  target=name()
  "=>"
  value=expression()

  {return target.conc( "= " ).conc( value ).conc( ";" );} // C++ assingment
}

// 1076.1 extension:
void case_statement() :
{}
{
  [ identifier() ":" ]  // identifier() was case_label()
                <CASE> expression() <IS>
                        (<WHEN> choices() "=>" sequence_of_statements() )+
                        // choices() was case_statement_alternative()
                <END> <CASE> [ identifier() ] ";"  // case_label
}

void choice() :
{}
{
    LOOKAHEAD(simple_expression())
    simple_expression()
  | LOOKAHEAD(discrete_range())
    discrete_range()
  | identifier()
  | <OTHERS>
}

void choices() :
{}
{
  choice() ( "|" choice() )*
}

void component_configuration() :
{}
{
  <FOR> instantiation_list() ":" identifier()  // all was component_specification()
                [ binding_indication() ";" ]
                [ block_configuration() ]
  <END> <FOR> ";"
}

void component_declaration() :
{}
{
  <COMPONENT> identifier() [ <IS> ]
      [ generic_clause() ]
      [ port_clause() ]
  <END> <COMPONENT> [ identifier() ] ";"
}

void component_instantiation_statement() :
{Trans label; Port unit;
 ArrayList generic= noList, port= noList;
}
{
  label= identifier() ":"  // label() was instantiation_label()
  unit= instantiated_unit()
  [ generic= generic_map_aspect() ]
  [ port= port_map_aspect() ] ";"
  { components.add( new Component( label, unit, generic, port) ); }
}


// 1076.1 - extension:
void composite_nature_definition() :
{}
{
    array_nature_definition()
  | record_nature_definition()
}


void composite_type_definition():
{}
{
    array_type_definition()
  | record_type_definition()
}


void concurrent_assertion_statement() :
{}
{
  [ identifier() ":" ] [ <POSTPONED> ] assertion() ";"  // identifier() was label()
}


void concurrent_procedure_call_statement() :
{}
{
  [ LOOKAHEAD( identifier() ":") identifier() ":" ]  // identifier() was label()
  [ <POSTPONED> ] procedure_call() ";"
}

void concurrent_signal_assignment_statement() :
{}
{
    [ LOOKAHEAD( identifier() ":") identifier() ":" ]  // identifier() was label()
    [ <POSTPONED> ]
    ( LOOKAHEAD(  target() "<=" options_() conditional_waveforms() ";")
        conditional_signal_assignment()
      | selected_signal_assignment() )
}

void conditional_signal_assignment() :
{}
{
  target() "<=" options_() conditional_waveforms() ";"
}

void conditional_waveforms() :
{}
{
  //( waveform() <WHEN> condition() <ELSE> )*
  //waveform() [ <WHEN> condition() ]
  waveform()
    ( LOOKAHEAD( <WHEN> expression() <ELSE>)  // expression() was condition()
        <WHEN> expression() <ELSE> waveform() )*  // expression() was condition()
    [ <WHEN> expression() ]  // expression was condition()
}

void configuration_declaration() :
{}
{
  <CONFIGURATION> identifier() <OF> identifier() <IS>
    configuration_declarative_part()
    block_configuration()
  <END> [ <CONFIGURATION> identifier() ] ";"
}

void configuration_declarative_item() :
{}
{
  try {
    use_clause()
  | attribute_specification()
  | group_declaration()
  }

  catch(ParseException e)
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATIVE ITEM");
  }
}


void configuration_declarative_part() :
{}
{
  ( configuration_declarative_item() )*
}

void configuration_item() :
{}
{
    LOOKAHEAD(block_configuration())
    block_configuration()
  | component_configuration()
}

void configuration_specification() :
{}
{
  <FOR> instantiation_list() ":" identifier() binding_indication() ";"
  // was component_specification()
}

void constant_declaration() :
{}
{
  <CONSTANT> identifier_list() ":" subtype_indication()
    [ ":=" expression() ] ";"
}



void constrained_array_definition() :
{}
{
  <ARRAY> index_constraint() <OF> subtype_indication()
}


void constraint() :
{}
{
    range_constraint()
  | index_constraint()
}

void context_clause() :
{}
{
  ( context_item() )*
}

void context_item() :
{}
{
    library_clause()
  | use_clause()
}

// Section 4:
// Declarations

// 1076.1 extension:
void terminal_declaration() :
{}
{
  <TERMINAL> identifier_list() ":" subnature_indication() ";"
}

void delay_mechanism() :
{}
{
    <TRANSPORT>
  | [ <REJECT> expression() ] <INERTIAL>
}

Trans design_file() :
{Trans ret;}
{
  ( ret= design_unit() )+ <EOF>
  {
  	return ret;
  }
}

Trans design_unit() :
{Trans ret;}
{
  context_clause() ret=library_unit()
  {
  	return ret;
  }
}

void designator() :
{}
{
    identifier()
  | operator_symbol()
}

void disconnection_specification() :
{}
{
  <DISCONNECT> guarded_signal_specification() <AFTER>
    expression() ";"
}

// Implemented for use in generate_statement() and loops only:
Range discrete_range() :
{Range ret, unfinishedRange= new Range(unfinished, unfinished);
 Trans from;}
{
    LOOKAHEAD(simple_expression() ( <TO> | <DOWNTO> ) ) // TO | DOWNTO was direction()
    ret= range() {return ret;}

    //For use as Vector(Identifier) only:
  | LOOKAHEAD( subtype_indication() )
    from= subtype_indication()
    {return new Range(from, new Trans("NOT TO BE USED - FROM discrete_range") ); }
  | range() {return unfinishedRange;}
}

Trans element_association() :
{Trans ret;}
{
  [ LOOKAHEAD(choices() "=>") choices() "=>"
    { System.err.println( "UNFINISHED CHOICES IN ELEMENT_ASSOCIATION"); }
  ]
  ret= expression()
  {return ret;}
}

void element_declaration() :
{}
{
  identifier_list() ":" subtype_indication() ";"
  // subtype_indication() was element_subtype_definition()
}

void entity_aspect() :
{}
{
    <ENTITY> identifier()
    [ LOOKAHEAD("(" identifier() ")")
    "(" identifier() ")" ]
  | <CONFIGURATION> identifier()
  | <OPEN>
}

// Section 5: Specifications
int entity_class() :
{}
{
    <ENTITY>                    { return ENTITY; }
  | <ARCHITECTURE>              { return ARCHITECTURE; }
  | <CONFIGURATION>             { return CONFIGURATION; }
  | <PROCEDURE>                 { return PROCEDURE; }
  | <FUNCTION>                  { return FUNCTION; }
  | <PACKAGE>                   { return PACKAGE; }
  | <TYPE>                      { return TYPE; }
  | <SUBTYPE>                   { return SUBTYPE; }
  | <CONSTANT>                  { return CONSTANT; }
  | <SIGNAL>                    { return SIGNAL; }
  | <VARIABLE>                  { return VARIABLE; }
  | <COMPONENT>                 { return COMPONENT; }
  | <LABEL>                     { return LABEL; }
  | <LITERAL>                   { return LITERAL; }
  | <UNITS>                     { return UNITS; }
  | <GROUP>                     { return GROUP; }
  | <FILE>                      { return FILE; }

  /** 1076.1 extensions: */
  | <SUBNATURE>                 { return SUBNATURE; }
  | <NATURE>                    { return NATURE; }
  | <TERMINAL>                  { return TERMINAL; }
}

void entity_class_entry()  :
{}
{
  entity_class() [ "<>" ]
}

void entity_class_entry_list() :
{}
{
  entity_class_entry() ( "," entity_class_entry() )*
}

void entity_declaration() :
{ Trans name;}
{
  <ENTITY> name= identifier() <IS>     //{ /*jjtThis.newBlock(); */}
          entity_header()
          entity_declarative_part()
  [ <BEGIN>
    entity_statement_part() ]
  <END> [ <ENTITY> ] [ identifier() ] ";"

  { //jjtThis.Check();//jjtThis.endBlock();
   Entity me= new Entity(  generics, ports);
   String nam= name.toString();
   me.write( nam +".ent");

   try {
      System.out.println( "ENTITY "+ nam+ " PROCESSED" );
      System.out.println( " GENERICs: ");
      Iterator it= generics.iterator();
      for( int i=0; i<generics.size(); i++)
         System.out.println( it.next().toString() );
      System.out.println( " PORTs: ");
      it= ports.iterator();
      for( int i=0; i<ports.size(); i++)
         System.out.println( it.next().toString() );
      System.out.println();
   }
   catch( Exception e) { System.err.println( "ERROR WHEN MAKING ENTITY REPORT"); }

  }
}


void entity_declarative_item() :
{}
{
  try {
    LOOKAHEAD(subprogram_declaration())
    subprogram_declaration()
  | subprogram_body()
  | type_declaration()
  | subtype_declaration()
  | constant_declaration()
  | signal_declaration()
  | shared_variable_declaration()
  | file_declaration()
  | alias_declaration()
  | LOOKAHEAD(attribute_declaration())
    attribute_declaration()
  | attribute_specification()
  | disconnection_specification()
  | use_clause()
  | LOOKAHEAD(<GROUP> identifier() <IS>)
    group_template_declaration()
  | group_declaration()
  // 1076.1 - Extensions:
  | nature_declaration()
  | subnature_declaration()
  | terminal_declaration()
  }
  catch( ParseException e )
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATIVE ITEM");
  }
}

// 4.8: Nature Declaration
// 1076.1 extension
void nature_declaration() :
{}
{
  <NATURE> identifier() <IS> nature_definition() ";"
}


// 1076.1 extension
void nature_definition() :
{}
{
    scalar_nature_definition()
  | composite_nature_definition()
}

void subnature_declaration() :
{}
{
  <SUBNATURE> identifier() <IS> subnature_indication() ";"
}


void subnature_indication() :
{}
{
  name() [index_constraint() ]   // name() was nature_mark()
  [ <TOLERANCE> expression() <ACROSS> expression() <THROUGH>]
}

void entity_declarative_part() :
{}
{
  ( entity_declarative_item() )*
}

void entity_designator() :
{}
{
  entity_tag() signature()
}

void entity_header() :
{}
{
  [ generic_clause() ]
  [ port_clause() ]
}

void entity_name_list() :
{}
{
  entity_designator() ( "," entity_designator() )*
  | <OTHERS>
  | <ALL>
}

void entity_specification() :
{}
{
        entity_name_list() ":" entity_class()
}

void entity_statement() :
{}
{   LOOKAHEAD( [ identifier() ":" ] [ <POSTPONED> ] assertion() ";" )
    // identifier() was label(); assertion() was concurrent_assertion_statement()
    [ identifier() ":" ] [ <POSTPONED> ] assertion() ";"
    // identifier() was label(); assertion() was concurrent_assertion_statement()
  | LOOKAHEAD([identifier() ":"] [<POSTPONED>] <PROCESS>)
    // identifier() was process_label()
    process_statement()
  | concurrent_procedure_call_statement()
}

void entity_statement_part() :
{}
{
  ( entity_statement() )*
}

void entity_tag() :
{}
{
    identifier()
  | <character_literal>
  | operator_symbol()
}

Trans enumeration_literal() :
{Token t;
 Trans ret;}
{
    t= <character_literal> {return new Trans(0).conc( t );}
  | ret= identifier() {return ret;}
}

void enumeration_type_definition() :
{}
{
  "(" enumeration_literal() ( "," enumeration_literal())* ")"
}

void exit_statement() :
{}
{
  [ identifier() ":" ] <EXIT> [ identifier() ]
   // 1st identifier() was label(); 2nd identifier() was loop_label()
    [ <WHEN> expression() ] ";"  // expression() was condition()
}

Trans expression() :
{ int op; boolean sequenceAllowed= true, isFirst= true;
  Trans ret, hlp; }
{
/**  relation() (
 *   ( <AND> relation() )* |
 *    ( <OR> relation() )*  |
 *    ( <XOR> relation() )* |
 *    [ <NAND> relation() ] |
 *    [ <NOR> relation() ]  |
 *    ( <XNOR> relation() )*
 *  )
 */
  ret= relation()
  ( LOOKAHEAD(1) op=logical_operator() hlp=relation()
    {
     if( !sequenceAllowed)
         System.err.println("NOT ALLOWED SEQUENCE OF LOGICAL OPERATORS.");
     switch( op)  {
      case AND:  ret.conc( " && " ).conc( hlp ); break;
      case OR:   ret.preconc( "(" ).conc( " || " ).conc( hlp ).conc( ")" ); break;
      case XOR:  ret.preconc( "( (bool) " ).conc( " != (bool) " ).conc(
          hlp ).conc( " )" ); break;
      case XNOR: ;

      case NAND: ret.preconc( "!( " ).conc( " && " ).conc( hlp ).conc( " )" );
         if( !isFirst)
            System.err.println("NAND CAN'T BE IN SEQUENCE OF LOGICAL OPERATORS.");
         sequenceAllowed= false; break;
      case NOR:  ret.preconc( "!( " ).conc( " || " ).conc( hlp ).conc( " )" );
         if( !isFirst)
            System.err.println("NOR CAN'T BE IN SEQUENCE OF LOGICAL OPERATORS.");
         sequenceAllowed= false; break;

     } //switch
     isFirst= false;
    }
  )*

  { return ret; }

}

Trans factor() :
{Trans ret, prim, prim2;}
{
     <ABS> prim= primary()
    { ret= new Trans(0).conc( "abs( " ).conc( prim ).conc( ")" );
      return ret;
	}
  | <NOT> prim= primary()
  	{ ret= new Trans(0).conc( "!( " ).conc( prim ).conc( ")" );
	  return ret;
  	}
  | ret= primary()
    [ LOOKAHEAD("**" primary() )
	  <EXP>		// it´s the same as "**"
	  prim2= primary()
	  { ret.preconc( " /*TODO*/exp(" ).conc( prim2 ).conc( ")" ); } // Needs C++ function exp(..)
    ]
    { return ret;}
}

void file_declaration() :
{}
{
  <FILE> identifier_list() ":" subtype_indication()
     [ file_open_information() ] ";"
}


void file_open_information() :
{}
{
  [ <OPEN> expression() ] <IS> expression()
}

void file_type_definition() :
{}
{
  <FILE> <OF> identifier() // identifier() was type_mark()
}

void floating_type_definition() : // Nowhere used by Grimm!
{}
{
  range_constraint()
}

Trans formal_part() :
{Trans ret, add;}
{
    LOOKAHEAD( identifier() "(" name() ")")  // name() was formal_designator()
    ret=identifier() "(" add=name() ")"  // name() was formal_designator()
    {return ret.conc( "(" ).conc( add ).conc( ")" ); }

  | LOOKAHEAD( identifier() "(" name() ")")
    // identifier() was type_mark(); name() was formal_designator()
    ret=identifier() "(" add=name() ")"
    {return ret.conc( "(" ).conc( add ).conc( ")" ); }

  | ret=name()   // name() was formal_designator()
    {return ret; }
}


Trans function_call() :
{Trans ret, pars=empty;}
{
  ret= name()
  [ LOOKAHEAD( "(" association_list() ")" )
    "(" association_list() ")"
    {ret.conc( "(" ).conc( unfinished ).conc( ")");}
  ]
  {return ret;}
}

//  Section 9.7
Trans generate_statement() :
{Trans ret= new Trans(0).conc( "for( " ), parameter_spec, statement;}
{
  identifier() ":"  // identifier() was generate_label()
  (   <FOR> parameter_spec= parameter_specification()
      {ret.conc( parameter_spec ).conc( ") {" ); }
    | <IF> expression() {ret.add("UNFINISHED if .. generate");}
  )  // was generation_scheme()

   <GENERATE>
    [ LOOKAHEAD(2)
      ( block_declarative_item()
        {ret.add("UNIMPLEMENTED block_declarative_item IN generate_statement");}
      )*
      <BEGIN>
    ]

    ( statement= architecture_statement()
      {ret.add( statement );}
    )*
    {ret.add( "}" ); }

  <END> <GENERATE> [ identifier() ] ";"  // identifier() was generate_label()
  {return ret;}
}

/** 1076.1 extension: */
Trans concurrent_break_statement() :
{Trans ret= new Trans(0);
 Trans breakList= new Trans();
 Trans condition= new Trans();
 boolean isInitialBreak= true;
 boolean hasBreakList= false;
 boolean hasCondition= false;
}
{
  [identifier() ":"] // identifier() was label()
  <BREAK>

  [ breakList= break_list()
    {hasBreakList= true;}
  ]

  [ condition=sensitivity_clause() // not used by us
    {isInitialBreak= false;
     hasCondition= true;
    }
  ]

  [ <WHEN>
    condition=expression() // expression() was condition()
    {isInitialBreak= false;
     hasCondition= true;
    }
  ]

   ";"

  {
      if(isInitialBreak && hasBreakList) {
         ret.add( "if(matlabInterface::initializationPass) {" );
         ret.add( breakList);
         ret.add( "}" );
      }
      else
      if(hasCondition && hasBreakList) {
         ret.add( "if(" ).conc( condition ).conc( ") {" );
         ret.add( breakList);
         ret.add( "}" );
      }
      else
         ret.add( "//untranslated(not needed) BREAK" );
      return ret;
  }
}

void generic_clause() :
{}
{
  <GENERIC> "(" interface_list( generics) ")" ";"
}

ArrayList generic_map_aspect() :
{ArrayList ret; }
{
  <GENERIC> <MAP> "(" ret=association_list() ")"
  {return ret;}
}

void group_constituent() :
{}
{
    name()
  | <character_literal>
}

void group_constituent_list() :
{}
{
  group_constituent() ( "," group_constituent() )*
}

void group_template_declaration() :
{}
{
  <GROUP> identifier() <IS> "(" entity_class_entry_list() ")" ";"
}

void group_declaration() :
{}
{
  <GROUP> identifier() ":" name()
  "(" group_constituent_list() ")" ";"
}

void guarded_signal_specification() :
{}
{
  signal_list() ":" identifier() // identifier() was type_mark()
}

Trans identifier() :
{ Token t; }
{
     t=<basic_identifier>    { return new Trans(0).conc( t ); }
  |  t=<extended_identifier> { return new Trans(0).conc( t ); }
}

ArrayList identifier_list() :
{ ArrayList ret= new ArrayList(); Trans id;}
{
  id= identifier() { ret.add( id.toString() );}
  ( "," id= identifier() { ret.add( id.toString() );} )*
  { return ret;}
}

void if_statement() :
{}
{
  [ identifier() ":" ]  // identifier() was if_label()
  <IF> expression() <THEN>  // expression() was condition()
  sequence_of_statements()
  ( <ELSIF> expression() <THEN>  // expression() was condition()
    sequence_of_statements() )*
  [ <ELSE>
    sequence_of_statements() ]
  <END> <IF> [ identifier() ] ";"  // expression() was if_label()
}

void incomplete_type_declaration() :
{}
{
  <TYPE> identifier() ";"
}

void index_constraint() :
{}
{
  "(" discrete_range() ( "," discrete_range() )* ")"
}

void index_specification() :
{}
{
    LOOKAHEAD( discrete_range() )
    discrete_range()
  | expression()
}

void index_subtype_definition() :
{}
{
  identifier() <RANGE> "<>" // ident=type_mark
}

void indexed_name() :
{}
{
  prefix() "(" expression() ( "," expression() )* ")"
}

Port instantiated_unit() :
{Trans ent, arch=new Trans("NO ARCHITECTURE SPECIFIED");}
{
    [ <COMPONENT> ] name()
      {return noPort;
       System.err.println( "UNFINISHED COMPONENTS!");
      }
  | <ENTITY> ent=identifier() [ "(" arch=identifier() ")" ]
      {return new Port( ent.toString(), arch.toString(), noTrans); }
  | <CONFIGURATION> name()
     {return noPort;
      System.err.println( "UNFINISHED CONFIGURATIONS!");
     }
}

void instantiation_list() :
{}
{
    identifier() ( "," identifier() )*
    // both identifier()-s were instantiation_label()-s
  | <OTHERS>
  | <ALL>
}

//void integer_type_definition() : // Nowhere used by Grimm
//{}
//{
//  range_constraint()
//}

void interface_constant_declaration( ArrayList to) :
{ ArrayList list; Trans type; String ini=""; Trans initial;}
{
  [ <CONSTANT> ] list=identifier_list() ":" [ <IN> ]
  type= subtype_indication()
  [ ":=" initial= expression() {ini= initial.toString();} ]
  {
      String typ= type.toString();
      for( int i=0; i<list.size(); i++) {
         String name= list.get(i).toString();
         Trans trans= new Trans(0).conc( typ ).conc( " " ).conc( name );
         Port port= new Port( name, typ, ini, trans);
         to.add( port);
      }
   }
}

//  Section 4.3.2:
void interface_declaration( ArrayList to) :
{}
{
    LOOKAHEAD( interface_constant_declaration( to) )
    interface_constant_declaration( to)
  | LOOKAHEAD(interface_signal_declaration( to) )
    interface_signal_declaration( to)
  | LOOKAHEAD(interface_variable_declaration() )
    interface_variable_declaration( to)
  | LOOKAHEAD(interface_file_declaration( to) )
    interface_file_declaration( to)

  /** 1076.1 extensions: */
  | interface_terminal_declaration( to)
  | interface_quantity_declaration( to)
}

// 1076.1 extension:
void interface_terminal_declaration( ArrayList to)  :
{}
{
  <TERMINAL> identifier_list() ":" subnature_indication()
}

// 1076.1 extension:
void interface_quantity_declaration( ArrayList to) :
{ ArrayList list; Trans type; String ini=""; Trans initial;
  Token mode; int mod=IN;
}
{
  <QUANTITY> list=identifier_list() ":"
  [ (mode= <IN> | mode= <OUT> | mode= <INOUT>) {mod= mode.kind;} ]
  type= subtype_indication()
  [ ":=" initial= expression() {ini= initial.toString();} ]
  {
      String typ= type.toString();
      for( int i=0; i<list.size(); i++) {
         String name= list.get(i).toString();
         Trans trans= new Trans(0).conc( mod==IN ? "const " : "" ).
            conc( typ ).conc( " &" ).conc( name );
         if( ini.equals("") && typeParameters!=noTrans )
            ini= typeParameters.toString();
         Port port= new Port( name, typ, ini, trans, mod);
         to.add( port);
      }
   }
}

void interface_file_declaration( ArrayList to) :
{}
{
  <FILE> identifier_list() ":" subtype_indication()
}

void interface_list( ArrayList to) :
{}
{
  interface_declaration( to)
  ( ";" interface_declaration( to) )*
  // both interface_declaration()-s were interface_element()-s
}

void interface_signal_declaration( ArrayList to) :
{}
{
  [<SIGNAL>] identifier_list() ":"
  [ mode() ] subtype_indication() [ <BUS> ] [ ":=" expression() ]
}

void interface_variable_declaration( ArrayList to) :
{}
{
  [<VARIABLE>] identifier_list() ":"
  [ mode() ] subtype_indication() [ ":=" expression() ]
}

void iteration_scheme() :
{}
{
    <WHILE> expression()  // expression() was condition()
  | <FOR> parameter_specification()
}

void library_clause() :
{}
{
  <LIBRARY> identifier_list() ";"  // identifier_list() was logical_name_list()
}

Trans library_unit() :
{Trans ret= new Trans( "UNFINISHED primary_unit!"); }
{
   { //Clearing those lists so new symbols can be collected there
    dots.clear();
    generics.clear();
    ports.clear();
    quantities.clear();
    components.clear();
   }

  (
    LOOKAHEAD(<ENTITY> | <CONFIGURATION> | <PACKAGE> identifier() )
    primary_unit()
  | ret= secondary_unit()
  )

  {return ret; }
}


Trans literal() :
{Trans ret;
 Token t;}
{
    LOOKAHEAD( numeric_literal() )
    ret= numeric_literal()
    {return ret;}
  | ret=enumeration_literal() {return ret;}
  | t= <string_literal> {return new Trans(0).conc( t ); }
  | t= <bit_string_literal>	{return new Trans(0).conc( t ); }
  | t= <NULL> {return new Trans(0).conc( t ); }
}

int logical_operator () :
{ Token t; }
{ (
    t= <AND>
  | t= <OR>
  | t= <NAND>
  | t= <NOR>
  | t= <XOR>
  | t= <XNOR>
  )
  { return t.kind; }
}

void loop_statement() :
{}
{
  [ identifier() ":" ]  // identifier() was loop_label()
  [ iteration_scheme() ] <LOOP>
                        sequence_of_statements()
  <END> <LOOP> [ identifier() ] ";"  // identifier() was loop_label()
}

int miscellaneous_operator() :
{}
{
    <EXP>               { return EXP; }
  | <ABS>               { return ABS; }
  | <NOT>               { return NOT; }
}

void mode() :
{}
{
    <IN>
  | <OUT>
  | <INOUT>
  | <BUFFER>
  | <LINKAGE>
}

Trans multiplying_operator() :
{}
{
    "*"                 { return new Trans(0).conc( "*" ); }
  | "/"                 { return new Trans(0).conc( "/" ); }
  | <MOD>               { return new Trans(0).conc( "/" ); } // integers only, OK
  | <REM>               { return new Trans(0).conc( "%" ); } // integers only, OK
}

Trans name() :
{Trans ret, append= new Trans(0);
 Extension ext;
}
{
// Skipped & unused productions...
/**  simple_name()
 * | operator_symbol()
 *  | selected_name()
 *  | indexed_name()
 *  | slice_name()
 *  | attribute_name()
 *
 * Kann ohne Linksrekursion wie folgt geschrieben werden:
 */
  (   ret= identifier()
    | ret= operator_symbol()
  )
  [ LOOKAHEAD(name_extension()) ext=name_extension()
  {
      while( ext!=null ) {
         if( ext.atr!=null ) {
            if( ext.atr.toString().toLowerCase().equals("dot"))
               dots.add( ret.toString()); //register in list of DOTs
            ext.atr.conc( "(" );
            ret.preconc( ext.atr );
            if( ext.par!=null)
               ret.conc( ", " ).conc( ext.par );
            ret.conc( ")" );
          // ext.trans in future? now not used here.
         } // care: translate with (), if not already: -> DOT()
         else //ret.conc (ext.trans);
            append.conc (ext.trans);
         ext= ext.next;
      }
      if( inSubtypeIndication) typeParameters= append;
      else ret.conc( append );
  }
  ]

  {
    return ret;
  }
}

Extension name_extension() :
{Extension ret= new Extension();
 Trans hlp= noTrans;
 Range range;}
{
  (
        LOOKAHEAD( signature() "'"  )
        signature() "'" ret.atr= attribute_simple_name()
        // attribute_simp_name() was attribute_designator()
         {} // now no signature...
        [ LOOKAHEAD( "(" expression() ")") "(" ret.par= expression() ")"]
      | "." ret.trans=suffix() {ret.trans.preconc(".");}
      | LOOKAHEAD( "(" discrete_range() ")" )
        "(" range=discrete_range() ")"// Implemented for vector(name) only.
        {ret.trans= range.from.preconc( "(" ).conc( ")" ); }
      | LOOKAHEAD( "(" expression() ("," expression() )* ")" )
        "(" ret.trans= expression()
        { if( !inSubtypeIndication) ret.trans.preconc("("); }
        ( "," hlp=expression() {ret.trans.conc(",").conc( hlp);} )*
         ")" { if( !inSubtypeIndication) ret.trans.conc(")");}

   // The following production is already in sign. "'" ... ,
   // since signature can be empty!
   // | "'" attribute_simple_name() [ "(" expression() ")"]
   // // attribute_simp_name=attribute_designator
  )
  [  LOOKAHEAD(name_extension() ) ret.next=name_extension() ]
  { return ret;}
}

// 1076.1 extension:
void nature_element_declaration() :
{}
{
  identifier_list() ":" element_subnature_definition()
}

// 1076.1 extension:
void element_subnature_definition() :
{}
{
  subnature_indication()
}

void next_statement() :
{}
{
  [ identifier() ":" ] <NEXT> [ identifier() ] [ <WHEN> expression() ] ";"
  // identifier()-s were: label() and loop_label(); expression() was condition()
}

void null_statement() :
{}
{
  [ identifier() ":" ] <NULL> ";"  // identifier() was label()
}

Trans numeric_literal() :
{Trans ret;}
{
    LOOKAHEAD(physical_literal())
    ret= physical_literal() {return ret;}
  | ret= abstract_literal() {return ret;}
}

void object_declaration() :
{}
{
  try {
    constant_declaration()
  | signal_declaration()
  | variable_declaration()
  | file_declaration()
  /** 1076.1 extensions: */
  | terminal_declaration()
  | quantity_declaration( noList)

  }
  catch( ParseException e )
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATION");
  }
}

Trans operator_symbol() :
{Token t;}
{
  t= <string_literal>
  {return new Trans(0).conc( t );}
}

void options_() :
{}
{
  [ <GUARDED> ] [ delay_mechanism() ]
}

void package_body() :
{}
{
  <PACKAGE> <BODY> identifier() <IS>
       package_body_declarative_part()
  <END> [ <PACKAGE> <BODY> ] [ identifier() ] ";"
}

void package_body_declarative_item() :
{}
{
  try {
    LOOKAHEAD(subprogram_declaration())
    subprogram_declaration()
  | subprogram_body()
  | type_declaration()
  | subtype_declaration()
  | constant_declaration()
  | shared_variable_declaration()
  | file_declaration()
  | alias_declaration()
  | use_clause()
  | LOOKAHEAD(<GROUP> identifier() <IS>)
    group_template_declaration()
  | group_declaration()
  }
  catch( ParseException e )
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATIVE ITEM");
  }
}

void package_body_declarative_part() :
{}
{
  ( package_body_declarative_item() )*
}

void package_declaration() :
{}
{
  <PACKAGE> identifier() <IS>
     package_declarative_part()
  <END> [ <PACKAGE> ] [ identifier() ] ";"
}

void package_declarative_item() :
{}
{
  try {
    subprogram_declaration()
  | type_declaration()
  | subtype_declaration()
  | constant_declaration()
  | signal_declaration()
  | shared_variable_declaration()
  | file_declaration()
  | alias_declaration()
  | component_declaration()
  | LOOKAHEAD( attribute_declaration() )
    attribute_declaration()
  | attribute_specification()
  | disconnection_specification()
  | use_clause()
  | LOOKAHEAD(<GROUP> identifier() <IS>)
    group_template_declaration()
  | group_declaration()

  // 1076.1 extensions:
  | nature_declaration()
  | subnature_declaration()
  | terminal_declaration()
  }
  catch(ParseException e)
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN DECLARATION");
  }
}

void package_declarative_part() :
{}
{
  ( package_declarative_item() )*
}

// Implemented for use in generate_statement and loops only:
Trans parameter_specification() :
{Trans ret=new Trans(0), ident; Range range;}
{
  ident=identifier() <IN> range=discrete_range()
  {ret.conc( "unsigned " ).conc( ident ).conc( "= " ).conc( range.from );
   ret.conc( "; " ).conc( ident ).conc( "<=" ).conc( range.to ).conc( "; " );
   ret.conc( ident ).conc( "++" );
   return ret;
  }
}

Trans physical_literal() :
{Trans ret, unit;}
{
  [ LOOKAHEAD(abstract_literal() name() )
    ret= abstract_literal()
  ]
  unit= name()
  {System.err.println( "UNFINISHED physical_literal!");
   return new Trans( "UNFINISHED physical_literal!");
  }
}

void physical_type_definition() :
{}
{
  range_constraint()
  <UNITS>
  identifier() ";" // identifier() was base_unit_declaration()
  ( secondary_unit_declaration() )*
  <END> <UNITS> [ identifier() ]
}

void port_clause() :
{}
{
  <PORT> "(" interface_list( ports) ")" ";"
}

ArrayList port_map_aspect() :
{ArrayList ret; }
{
  <PORT> <MAP> "(" ret=association_list() ")"
  {return ret; }
}

void prefix() :
{}
{
    LOOKAHEAD( function_call() )
    function_call()
  | name()
}

Trans primary() :
{Trans ret;}
{
	LOOKAHEAD( qualified_expression() )
    ret= qualified_expression()
    { return ret;}
  | LOOKAHEAD( function_call() )
    ret= function_call()
    { return ret;}
  | LOOKAHEAD(name())
    ret= name()
    { return ret;}

  | LOOKAHEAD(literal())
    ret= literal()
    { return ret;}

  | LOOKAHEAD( aggregate() )
    ret= aggregate()
    { return ret;}

  | LOOKAHEAD( "(" expression() ")")
    "(" ret= expression() ")"
    { return (new Trans(0).conc( "( ") ).conc( ret).conc( ")");}

  | LOOKAHEAD( type_conversion() )
    ret= type_conversion()
    {System.err.println( "UNFINISHED type_conversion!");
     return new Trans( "UNFINISHED type_conversion");
    }

  | ret= allocator()
  	{System.err.println( "UNFINISHED allocator!");
    return new Trans( "UNFINISHED allocator");
   }
}


void primary_unit() :
{}
{
    entity_declaration()
  | configuration_declaration()
  | LOOKAHEAD(<PACKAGE> identifier())
    package_declaration()
}


void procedure_call() :
{}
{
  name() [ "(" association_list() ")" ]
}

void procedure_call_statement() :
{}
{
   [ LOOKAHEAD( identifier() ":") identifier() ":" ]  // identifier() was label()
   procedure_call() ";"
}

void process_declarative_item() :
{}
{
    LOOKAHEAD(subprogram_declaration())
    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( <GROUP> identifier() <IS> )
    group_template_declaration()
  | group_declaration()
}

void process_declarative_part() :
{}
{
  ( process_declarative_item() )*
}

void process_statement() :
{}
{
   [ identifier() ":" ]  // identifier() was process_label()
   [ <POSTPONED> ] <PROCESS>                    { /*jjtThis.newBlock(); */}
   [ "(" sensitivity_list() ")" ] [ <IS> ]
     process_declarative_part()
   <BEGIN>
     process_statement_part()
   <END> [ <POSTPONED> ] <PROCESS> [ identifier() ] ";"  // identifier() process_label()

   {
     //jjtThis.Check();
     //jjtThis.endBlock();
   }
}

void process_statement_part() :
{}
{
  ( sequential_statement() )*
}

Trans qualified_expression() :
{Trans ret;}
{
  identifier() "'"  // identifier() was type_mark()
  (   LOOKAHEAD( aggregate() )
      aggregate()
    | "(" expression() ")"
  )
  {System.err.println( "UNFINISHED qualified_expression!");
   return new Trans( "UNFINISHED qualified_expression");
  }
}

// Implemented for use in generate_statement and loops only:
Range range() :
{Range unfinishedRange= new Range(unfinished, unfinished);
 Trans from, to;}
{
    LOOKAHEAD( simple_expression() (<TO> | <DOWNTO>) )  // simple_expression() was direction() )
    from=simple_expression()
    (  <TO>
     | <DOWNTO> {return unfinishedRange;}
    )
    to=simple_expression()  // simple_expression() direction()
    {return new Range(from, to); }
  | name() {return unfinishedRange;}
}

void range_constraint() :
{}
{
  <RANGE> range()
}

void record_nature_definition() :
{}
{
  <RECORD>
  ( nature_element_declaration() )+
  <END> <RECORD> [ identifier() ]
}

void record_type_definition() :
{}
{
  <RECORD>
  ( element_declaration() )+
  <END> <RECORD> [ identifier() ]
}

Trans relation() :
{
  Trans ret, op, expr2;
}
{
  ret= shift_expression()
  [ LOOKAHEAD(1)
  	op=relational_operator()
  	expr2= shift_expression()
  	{
		ret.conc( op).conc( expr2);
  	}
  ]
  {
  	return ret;
  }
}

Trans relational_operator() :
{}
{
    <EQ>                { return new Trans(0).conc( "==" ); }
  | <NEQ>               { return new Trans(0).conc( "!=" ); }
  | <LO>                { return new Trans(0).conc( "<" ); }
  | <LE>                { return new Trans(0).conc( "<=" ); }
  | <GT>                { return new Trans(0).conc( ">" ); }
  | <GE>                { return new Trans(0).conc( ">=" ); }
}

void report_statement() :
{}
{
  [ identifier() ":" ]  <REPORT> expression()  // identifier() was label()
  [ <SEVERITY> expression() ] ";"
}

void return_statement() :
{}
{
  [ identifier() ":" ] <RETURN> [ expression() ] ";"  // identifier() was label()
}

// 1076.1 - extension:
void scalar_nature_definition() :
{}
{
  identifier() <ACROSS> identifier() <THROUGH>  // identifier() was type_mark()
}

void scalar_type_definition() :
{}
{
    LOOKAHEAD(range_constraint() <UNITS> )
    physical_type_definition()
  |
    LOOKAHEAD(enumeration_type_definition())
    enumeration_type_definition()

/*  | integer_type_definition()
 *  | floating_type_definition()
 * integer- and floating_type_definition are both range_constraint, thus:
 */
  |
    range_constraint()
}

Trans secondary_unit() :
{Trans ret= new Trans( "UNFINISHED package_body"); }
{
    LOOKAHEAD( <ARCHITECTURE> )
    ret= architecture_body()
    {
		return ret;
    }
  | LOOKAHEAD( <PACKAGE> <BODY> )
    package_body()
    {
		return ret;
    }
}

void secondary_unit_declaration() :
{}
{
  identifier() "=" physical_literal() ";"
}

void selected_name() : // Can be directly replaced by name, as it seems.
                       // See Grimm's note at end of this function....
{}
{
  /**
   * prefix() "." suffix()
   * results in left-recursion...
   * the follwoing does the same (i hope ...)
   */

  ( identifier() | operator_symbol() )
  [ LOOKAHEAD( name_extension() )  name_extension() ]

  /**
   * semantic analysis has to ensure that last production
   * was "." suffix()
   */
}

void selected_signal_assignment() :
{}
{
  <WITH> expression() <SELECT>
  target()  "<=" options_() selected_waveforms() ";"
}

void selected_waveforms() :
{}
{
  waveform() <WHEN> choices()
  ("," waveform() <WHEN> choices() )*
}

Trans sensitivity_clause() :
{Trans ret;}
{
  <ON>
  ret=sensitivity_list()
  {return ret;}
}

// Implementation for initial and discontinuity BREAK, not for processes/other stuff...
Trans sensitivity_list() :
{Trans item, ret=new Trans();}
{
  item=name()
  {ret.add( item );}

  (
    ","
    item=name()
    {ret.conc( " || " ).conc( item );}
  )*

  {return ret;}
}

void sequence_of_statements() :
{}
{
  ( sequential_statement() )*
}

void sequential_statement() :
{}
{
  try {
    (
      LOOKAHEAD(3)
      wait_statement()
    | LOOKAHEAD(3)
      assertion_statement()
    | LOOKAHEAD(3)
      report_statement()
    | LOOKAHEAD(  [ identifier() ":" ] target() "<=" )  // identifier() was label()
      signal_assignment_statement()
    | LOOKAHEAD(  [ identifier() ":" ] target() ":=" )  // identifier() was label()
      variable_assignment_statement()
    | LOOKAHEAD(3)
      procedure_call_statement()
    | LOOKAHEAD(3)
      if_statement()
    | LOOKAHEAD(3)
      case_statement()
    | LOOKAHEAD(3)
      loop_statement()
    | LOOKAHEAD(3)
      next_statement()
    | LOOKAHEAD(3)
      exit_statement()
    | LOOKAHEAD(3)
      return_statement()
    | LOOKAHEAD(3)
      null_statement()

    /** 1076.1 extensions: */
    | break_statement()
    )
  }

  // Error handling: skip till next semicolon.
  catch (ParseException e)
  {
    error_skipto(SEMICOLON, "SYNTAX ERROR IN sequential statement");
  }
}

Trans shift_expression() :
{Trans ret, op, expr2;}
{
  ret= simple_expression()
  [ LOOKAHEAD(2)
    op=shift_operator()
  	expr2= simple_expression()
  	{
		ret.conc( op).conc( expr2);
  	}
  ]
  {
  	return ret;
  }
}

//TODO - not done, as it's mainly for VHDL digital stuff
Trans shift_operator() :
{}
{
    <SLL>               { return new Trans("sll"); }
  | <SRL>               { return new Trans("srl"); }
  | <SLA>               { return new Trans("sla"); }
  | <SRA>               { return new Trans("sra"); }
  | <ROL>               { return new Trans("rol"); }
  | <ROR>               { return new Trans("ror"); }
}

Trans sign() :
{}
{
    "+" {return new Trans(0).conc( "+" );}
  | "-" {return new Trans(0).conc( "-" );}
}

void signal_assignment_statement() :
{}
{
  [ LOOKAHEAD( identifier() ":") identifier() ":" ]  // identifier() was label()
  target() "<=" [ delay_mechanism() ] waveform() ";"

}

void signal_declaration() :
{}
{
    <SIGNAL> identifier_list() ":"
    subtype_indication() [ <REGISTER> | <BUS> ] [ ":=" expression() ] ";"
    //  [ <REGISTER> | <BUS> ] was signal_kind()
}

void signal_list() :
{}
{
    name() ( "," name() )*
  | <OTHERS>
  | <ALL>
}

void signature() :
{}
{
  [ identifier() ( LOOKAHEAD( "," identifier() ) "," identifier() )* ]
  // all identifier()-s were type_mark()-s
  [ <RETURN> identifier() ]
}


Trans simple_expression() :
{ Trans sig, op, term1, term2, ret= new Trans(0);}
{
   [ sig= sign()
   	 {ret.conc( sig); }
   ]

   term1= term()
   {ret.conc( term1); }

   ( LOOKAHEAD(2)
     op= adding_operator()
     term2= term()
	  {ret.conc( op).conc( term2); }
   )*

   {return ret; }
}

/* void slice_name() : // Nowhere used by Grimm; in comment only!
{}
{
  prefix() "(" discrete_range() ")"
}
*/

void subprogram_body() :
{}
{
  subprogram_specification() <IS>
     subprogram_declarative_part()
  <BEGIN>
         subprogram_statement_part()
  <END> [ <PROCEDURE> | <FUNCTION> ] [ designator() ] ";"
  // designator() was subprogram_kind()
}

void subprogram_declaration() :
{}
{
  subprogram_specification() ";"
}

void subprogram_declarative_item() :
{}
{
    LOOKAHEAD(subprogram_declaration())
    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( <GROUP> identifier() <IS>)
    group_template_declaration()
  | group_declaration()
}

void subprogram_declarative_part() :
{}
{
  ( subprogram_declarative_item() )*
}

void subprogram_specification() :
{}
{
  <PROCEDURE> designator() [ "(" interface_list( noList) ")" ]
  | [ <PURE> | <IMPURE> ]  <FUNCTION> designator()
     [ "(" interface_list( noList) ")" ]
                <RETURN> identifier()  // identifier() was type_mark()
}

void subprogram_statement_part() :
{}
{
  ( sequential_statement() )*
}

void subtype_declaration() :
{}
{
  <SUBTYPE> identifier() <IS> subtype_indication() ";"
}

// Section 4.1:
Trans subtype_indication() :
{ Trans ret=new Trans( "UNIMPLEMENTED PART OF subtype_indication....");
  inSubtypeIndication= true;
  typeParameters= noTrans;
}
{
  /* enumeration resolves conflict ! After implementation of symbol tables
   * this can be replaced by semantic lookahead.
   */
  // every name() was type_mark() or name()
  (
    LOOKAHEAD(name() name() constraint())
    name() name() constraint()
      [ LOOKAHEAD(tolerance_aspect())tolerance_aspect() ]

  | LOOKAHEAD( name() constraint() )
    name() constraint()
      [ LOOKAHEAD(tolerance_aspect()) tolerance_aspect() ]

  | LOOKAHEAD( name() name() )
    name() name()
      [ LOOKAHEAD(tolerance_aspect())tolerance_aspect() ]

  | LOOKAHEAD( name() )
    ret= name()
      [ LOOKAHEAD(tolerance_aspect()) tolerance_aspect() ]
  )
  {
   inSubtypeIndication= false;
   return ret;
  }
}

// 1076.1 extension:
void tolerance_aspect() :
{}
{
  <TOLERANCE> expression()
}

// Section 4.3.1.6: Quantity declaration
// 1076.1 extension:
void quantity_declaration( ArrayList to) :
{}
{
    LOOKAHEAD(free_quantity_declaration( to) ) // Good
    interface_quantity_declaration( to) ";"
  | LOOKAHEAD(branch_quantity_declaration() )
    branch_quantity_declaration()
  | source_quantity_declaration()
}

// 1076.1 extension:
void free_quantity_declaration( ArrayList to) : // UNUSED - JUST in LOOKAHEAD.
{ ArrayList list; Trans type; String ini=""; Trans initial;}
{
  <QUANTITY> list=identifier_list() ":"
  type= subtype_indication()
  [ ":=" initial= expression() {ini= initial.toString();} ]
  ";"
  {
      String typ= type.toString();
      for( int i=0; i<list.size(); i++) {
         String name= list.get(i).toString();
         // trans - how it is translated to C++ definition
         Trans trans= new Trans(0).conc( typ ).conc( " " ).conc( name );
         Port port= new Port( name, typ, ini, trans);
         to.add( port);
      }
   }
}

// 1076.1 extension:
void branch_quantity_declaration() :
{}
{
  <QUANTITY> [LOOKAHEAD(across_aspect()) across_aspect()]
	     [LOOKAHEAD(through_aspect()) through_aspect()]
	     name() [<TO> name()] ";"  // both name()-s were terminal_aspect()-s
}


// 1076.1 extension:
void source_quantity_declaration() :
{}
{
  <QUANTITY> identifier_list() ":" subtype_indication() source_aspect() ";"
}

// 1076.1 extension:
void across_aspect() :
{}
{
  identifier_list() [ tolerance_aspect() ] [ ":=" expression() ] <ACROSS>
}

// 1076.1 extension:
void through_aspect() :
{}
{
  identifier_list() [ tolerance_aspect() ] [ ":=" expression() ] <THROUGH>
}

// 1076.1 extension:
void source_aspect() :
{}
{
    <SPECTRUM> simple_expression() "," simple_expression()
  | <NOISE>    simple_expression()
}

Trans suffix() :
{Trans ret= noTrans; Token t;}
{
 (   ret= identifier()
  | t= <character_literal> {ret= new Trans(0).conc( t ); }
  | ret= operator_symbol()
  | t= <ALL> {ret= new Trans(0).conc( t );}
 )
 { return ret;}
}

void target() :
{}
{
    name()
  | aggregate()
}

Trans term() :
{ Trans ret, op, factor2; }
{
  ret= factor()
  ( LOOKAHEAD(2)
  	 op= multiplying_operator()
	 factor2= factor()
	 {
	 	ret.conc( op).conc( factor2);
	 }
  )*

  {
  	return ret;
  }
}

Trans type_conversion() :
{Trans ret;}
{
  identifier() "(" expression() ")"
  {System.err.println( "UNFINISHED type_conversion!");
   return new Trans( "UNFINISHED type_conversion");
  }
}

void type_declaration() :
{}
{
    LOOKAHEAD( <TYPE> identifier() <IS> )
    <TYPE> identifier() <IS> type_definition() ";"
    // bothe identifier()-s were full_type_declaration()-s
  | incomplete_type_declaration()
}

void type_definition() :
{}
{
    scalar_type_definition()
  | composite_type_definition()
  | access_type_definition()
  | file_type_definition()
}

void unconstrained_array_definition() :
{}
{
  <ARRAY> "(" index_subtype_definition()
    ( "," index_subtype_definition() )* ")"
      <OF> subtype_indication()
}

void use_clause() :
{}
{
   <USE> selected_name() ( "," selected_name() )* ";"
}

void variable_assignment_statement() :
{}
{
  [ LOOKAHEAD( identifier() ":") identifier() ":" ]  // identifier() was label()
  target()  ":=" expression() ";"
}

void variable_declaration() :
{}
{
  [ <SHARED> ] <VARIABLE> identifier_list() ":"
  subtype_indication() [ ":=" expression() ] ";"
}

void wait_statement() :
{}
{
   [ LOOKAHEAD( identifier() ) ":" identifier() ":"]  // identifier() was label()
   <WAIT> [ sensitivity_clause() ]
   [ <UNTIL> expression() ] [ <FOR> expression() ] ";"
   // 1st expression() was condition_clause(); 2nd one was timeout_clause()
}

void waveform() :
{}
{
  waveform_element() ( "," waveform_element() )*
  | <UNAFFECTED>
}

void waveform_element() :
{}
{
     LOOKAHEAD(<NULL>)
     <NULL>             [<AFTER> expression() ]
  |  expression() [ <AFTER> expression() ]
}

// Section 15: Simultaneous statements
// 1076.1 extension
Trans simultaneous_statement_part()   :
{Trans hlp, ret= new Trans(0);}
{
  ( hlp= simultaneous_statement()
  {
  	ret.add( hlp);
  }
  )*

  {
  	return ret;
  }
}

// 1076.1 extension:
Trans simultaneous_statement() :
{Trans ret= new Trans( "UNFINISHED PART OF simultaneous_statement"); }
{
  (
     LOOKAHEAD(simple_simultaneous_statement())
     ret= simple_simultaneous_statement()
   | LOOKAHEAD( [identifier() ":" ] <IF> expression() <USE> )
     // There was a Christoph´s little typing error
     // identifier() was if_label(); expression() was condition()
     ret= simultaneous_if_statement()
   | LOOKAHEAD(simultaneous_case_statement())
     simultaneous_case_statement()
   | LOOKAHEAD(4) // procedural is at least as 4th position...
     simultaneous_procedural_statement()
   | ret= simultaneous_null_statement()
  )
	{return ret; }
}

// 1076.1 extension:
Trans simple_simultaneous_statement() :
{Trans hlp, ret;}
{
  [ LOOKAHEAD( identifier() ":") identifier() ":"]   // identifier() was label()
  [<PURE>|<IMPURE>] ret= simple_expression()
  "==" hlp= simple_expression() [ tolerance_aspect() ] ";"
  {
  	return ret.conc("= ").conc( hlp).conc(";");
  }
}

// 1076.1 extension:
Trans simultaneous_if_statement() :
{Trans cond, cond2, if_sim, sim2, else_sim, ret= new Trans(0).conc( "if( " );}
{
  [ identifier() ":"] <IF> cond= expression() <USE>
   // identifier() was if_label; expression() was condition()

  if_sim= simultaneous_statement_part()
  { ret.conc( cond ).conc( ") {" ).add( new Trans(if_sim) ).add( "}"); }

  ( <ELSIF> cond2= expression() <USE> sim2= simultaneous_statement_part()
     // expression() was condition()
    {ret.add("else if( ").conc( cond2 ).conc( ") {" ).
         add( new Trans(sim2) ).add( "}" );}
  )*

  [ <ELSE> else_sim= simultaneous_statement_part()
  	{ret.add( "else {" ).add( new Trans(else_sim) ).add( "}" );}
  ]
  <END> <USE> [ identifier()] ";"  // identifier() was if_label(); TODO: check equality

  {return ret; }
}

// 1076.1 extension:
void simultaneous_case_statement() :
{}
{
  [ identifier() ":"] <CASE> expression() <USE>  // identifier() was case_label()
    (simultaneous_alternative())*
  <END> <CASE> [ identifier() ] ";"  // identifier() was case_label()
}

// 1076.1 extension:
void simultaneous_alternative() :
{}
{
  <WHEN> choices() <USE> simultaneous_statement_part()
}

// 1076.1 extension:
void simultaneous_procedural_statement() :
{}
{
  [identifier() ":"] [<PURE>|<IMPURE>] <PROCEDURAL> [<IS>]  // identifier() was procedural_label()
    procedural_declarative_part()
   <BEGIN>
     procedural_statement_part()
   <END> <PROCEDURAL> [ identifier()] ";"  // identifier() was procedural_label()
}

// 1076.1 extension:
void procedural_declarative_part() :
{}
{
  ( procedural_declarative_item() )*
}

// 1076.1 extension:
void procedural_declarative_item() :
{}
{
    LOOKAHEAD(subprogram_declaration())
    subprogram_declaration()
  | subprogram_body()
  | type_declaration()
  | subtype_declaration()
  | constant_declaration()
  | variable_declaration()
  | alias_declaration()
  | LOOKAHEAD(attribute_declaration())
    attribute_declaration()
  | attribute_specification()
  | use_clause()
  | LOOKAHEAD(group_template_declaration())
    group_template_declaration()
  | group_declaration()
}

// 1076.1 extension:
void procedural_statement_part() :
{}
{
  ( sequential_statement() )*
}

// 1076.1 extension:
Trans simultaneous_null_statement() :
{}
{
  [ identifier() ":"] <NULL> ";"  // identifier() was label()
  {
  	return empty;
  }
}

Trans attribute_simple_name() :
{Trans ret=noTrans; Token t;}
{
  ret=identifier() { return ret;}
  | t=<RANGE>
  {System.err.println( "UNFINISHED attribute_simple_name WITH range");
   return new Trans(0).conc( t );
  }
}

// 1076.1 extension:
void shared_variable_declaration() :
{}
{
  [ <SHARED> ] <VARIABLE> identifier_list() ":"
  subtype_indication() [ ":=" expression() ] ";"
}

// for error recovery:
JAVACODE void error_skipto(int kind, String message)
{
  errs.Error(message);
  Token t;
  do
  {
    t = getNextToken();
  } while ((t.kind != kind));
}