Click here to Skip to main content
15,891,184 members
Articles / Programming Languages / Java

Building a Distributed Object System with .NET and J2EE Using IIOP.NET

Rate me:
Please Sign up or sign in to vote.
4.88/5 (49 votes)
1 Jul 20037 min read 303.9K   3.6K   95  
This article demonstrates the use of IIOP.NET
/* Generated By:JJTree&JavaCC: Do not edit this line. IDLParser.java */
package parser;

import symboltable.*;
import java.util.Stack;

public class IDLParser/*@bgen(jjtree)*/implements IDLParserTreeConstants, IDLParserConstants {/*@bgen(jjtree)*/
  protected JJTIDLParserState jjtree = new JJTIDLParserState();
        /** the symbol table */
        private SymbolTable m_symbolTable = new SymbolTable();

        public SymbolTable getSymbolTable() {
                return m_symbolTable;
        }


        // stores the last #pragma prefix value found
        private String m_lastPrefix = "";

        // stores reference to the module node inserted for a pragma prefix (if any)
        private ASTmodule m_modForPrefix = null;
        // stores reference to definition for the module node inserted for a pragma prefix (if any)
        private ASTdefinition m_defForPrefix = null;

/* handling of pragma id outside of a type definition */
  final public void pragmaID() throws ParseException {
  String ident = ""; String val = "";
    jj_consume_token(8);
    jj_consume_token(9);
    ident = identifier();
    val = string_literal();
                Scope currentScope = m_symbolTable.getCurrentScope();
                if (!m_lastPrefix.equals("")) {
                        // prepend prefix
                        val = val.Insert(val.indexOf(":") + 1, m_lastPrefix + "/");
                }

                currentScope.addPragmaID(ident, val); // add pragma ID

  }

/* handling of pragma id inside a type definition */
  final public void pragmaIDInside() throws ParseException {
  String ident = ""; String val = "";
    jj_consume_token(8);
    jj_consume_token(9);
    ident = identifier();
    val = string_literal();
                Scope currentScope = m_symbolTable.getCurrentScope();
                currentScope = currentScope.getParentScope(); // get the scope this type is defined in, the id must be added to this scope
                if (!m_lastPrefix.equals("")) {
                        // prepend prefix
                        val = val.Insert(val.indexOf(":") + 1, m_lastPrefix + "/");
                }

                currentScope.addPragmaID(ident, val); // add pragma ID

  }

/* handling of pragma prefix */
  final public void pragmaPrefix() throws ParseException {
  String val = "";
    jj_consume_token(8);
    jj_consume_token(10);
    val = string_literal();
                val = val.trim();
                if (m_lastPrefix.equals(val)) { {if (true) return;} } // same pragma prefix, nothing to do

                if ( (!(val.equals(""))) && (m_symbolTable.getCurrentScope() != m_symbolTable.getTopScope())) {
                        {if (true) throw new ParseException("invalid scope for using a #pragma prefix, only usable outside of module declarations");}
                }

                if (m_symbolTable.isPragmaScopeOpen()) {
                        // close the scopes up to the pragma-scope (incl. pragma scope)
                        m_symbolTable.closePragmaScope();
                        // close module node for pragma
                        jjtree.closeNodeScope(m_modForPrefix, true);
                        jjtree.closeNodeScope(m_defForPrefix, true);
                        m_modForPrefix = null;
                        m_defForPrefix = null;
                        // open scopes for new pragma, if val != ""
                        m_symbolTable.openPragmaScope(val);
                } else {
                        m_symbolTable.openPragmaScope(val);
                }
                // open a defintion and an included module node into the parse tree if val != "" --> insert a module opening for pragma prefix
                if (!(val.equals(""))) {
                        m_defForPrefix = new ASTdefinition(this, JJTDEFINITION);
                        jjtree.openNodeScope(m_defForPrefix);
                        m_modForPrefix = new ASTmodule(this, JJTMODULE);
                        jjtree.openNodeScope(m_modForPrefix);
                        m_modForPrefix.setIdent(val);
                }
                m_lastPrefix = val;
  }

/* Production 1, chapter 3.4 in CORBA 2.3.1 spec, pragma prefix handling added here */
  final public ASTspecification specification() throws ParseException {
 /*@bgen(jjtree) specification */
  ASTspecification jjtn000 = new ASTspecification(this, JJTSPECIFICATION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 8:
      case 12:
      case 15:
      case 16:
      case 20:
      case 21:
      case 30:
      case 45:
      case 46:
      case 58:
      case 59:
      case 63:
      case 73:
        label_1:
        while (true) {
          if (jj_2_1(2)) {
            definition();
          } else if (jj_2_2(2)) {
            pragmaPrefix();
          } else {
            jj_consume_token(-1);
            throw new ParseException();
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case 8:
          case 12:
          case 15:
          case 16:
          case 20:
          case 21:
          case 30:
          case 45:
          case 46:
          case 58:
          case 59:
          case 63:
          case 73:
            ;
            break;
          default:
            jj_la1[0] = jj_gen;
            break label_1;
          }
        }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
        if (m_modForPrefix != null) {
                jjtree.closeNodeScope(m_modForPrefix, true); // close inserted module node scope for prefix, if one is open after parse completition
                jjtree.closeNodeScope(m_defForPrefix, true); // close inserted definition node scope for prefix
        }
        {if (true) return jjtn000;}
        break;
      case 0:
        jj_consume_token(0);
                jjtree.closeNodeScope(jjtn000, true);
                jjtc000 = false;
                {if (true) return jjtn000;}
        break;
      default:
        jj_la1[1] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
  }
    }
    throw new Error("Missing return statement in function");
  }

/* Production 2, chapter 3.4 CORBA 2.3.1, added pragma id and prefix parsing, moved semicolon after value to production 14-17 */
  final public void definition() throws ParseException {
 /*@bgen(jjtree) definition */
  ASTdefinition jjtn000 = new ASTdefinition(this, JJTDEFINITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 45:
      case 46:
      case 58:
      case 59:
      case 63:
        type_dcl();
        jj_consume_token(11);
        break;
      case 30:
        const_dcl();
        jj_consume_token(11);
        break;
      case 73:
        except_dcl();
        jj_consume_token(11);
        break;
      default:
        jj_la1[2] = jj_gen;
        if (jj_2_3(2)) {
          interfacex();
          jj_consume_token(11);
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case 12:
            module();
            jj_consume_token(11);
            break;
          default:
            jj_la1[3] = jj_gen;
            if (jj_2_4(2)) {
              value();
            } else {
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case 8:
                pragmaID();
                break;
              default:
                jj_la1[4] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
              }
            }
          }
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 3, chapter 3.4 in CORBA 2.3.1 spec */
  final public void module() throws ParseException {
 /*@bgen(jjtree) module */
  ASTmodule jjtn000 = new ASTmodule(this, JJTMODULE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(12);
      ident = identifier();
                                  m_symbolTable.openScope(ident);
      jj_consume_token(13);
      label_2:
      while (true) {
        definition();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 8:
        case 12:
        case 15:
        case 16:
        case 20:
        case 21:
        case 30:
        case 45:
        case 46:
        case 58:
        case 59:
        case 63:
        case 73:
          ;
          break;
        default:
          jj_la1[5] = jj_gen;
          break label_2;
        }
      }
      jj_consume_token(14);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
        jjtn000.setIdent(ident);
        // close scope for this module after parsing
        m_symbolTable.closeScope();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 4: chapter 3.4, CORBA 2.3.1. spec (renamed interface -> interfacex, because interface is a keyword in java) */
  final public void interfacex() throws ParseException {
 /*@bgen(jjtree) interfacex */
  ASTinterfacex jjtn000 = new ASTinterfacex(this, JJTINTERFACEX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_5(4)) {
        interface_dcl();
      } else if (jj_2_6(4)) {
        forward_dcl();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 5: chapter 3.4, CORBA 2.3.1. spec */
  final public void interface_dcl() throws ParseException {
 /*@bgen(jjtree) interface_dcl */
  ASTinterface_dcl jjtn000 = new ASTinterface_dcl(this, JJTINTERFACE_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      interface_header();
        // add the interface symbol, after the header is completed
        // get the header node
        SimpleNodeWithIdent header = (SimpleNodeWithIdent) jjtree.peekNode();
        Scope currentScope = m_symbolTable.getCurrentScope();
        currentScope.addSymbol(header.getIdent());
        m_symbolTable.openScope(header.getIdent()); // open a scope for type declaration inside the interface

      jj_consume_token(13);
      interface_body();
      jj_consume_token(14);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
        m_symbolTable.closeScope(); // close the scope for type declarations inside the interface

    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 6: chapter 3.4, CORBA 2.3.1. spec */
  final public void forward_dcl() throws ParseException {
 /*@bgen(jjtree) forward_dcl */
  ASTforward_dcl jjtn000 = new ASTforward_dcl(this, JJTFORWARD_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
  boolean isAbstract = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 15:
        jj_consume_token(15);
                 isAbstract = true;
        break;
      default:
        jj_la1[6] = jj_gen;
        ;
      }
      jj_consume_token(16);
      ident = identifier();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setIdent(ident);
    jjtn000.setAbstract(isAbstract);
    Scope currentScope = m_symbolTable.getCurrentScope();
    currentScope.addFwdDecl(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 7: chapter 3.4, CORBA 2.3.1. spec */
  final public void interface_header() throws ParseException {
 /*@bgen(jjtree) interface_header */
  ASTinterface_header jjtn000 = new ASTinterface_header(this, JJTINTERFACE_HEADER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
  boolean isAbstract = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 15:
        jj_consume_token(15);
                 isAbstract = true;
        break;
      default:
        jj_la1[7] = jj_gen;
        ;
      }
      jj_consume_token(16);
      ident = identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 17:
        interface_inheritance_spec();
        break;
      default:
        jj_la1[8] = jj_gen;
        ;
      }
                                                                                                            jjtree.closeNodeScope(jjtn000, true);
                                                                                                            jjtc000 = false;
                                                                                                            jjtn000.setIdent(ident); jjtn000.setAbstract(isAbstract);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 8: chapter 3.4, CORBA 2.3.1 */
  final public void interface_body() throws ParseException {
 /*@bgen(jjtree) interface_body */
  ASTinterface_body jjtn000 = new ASTinterface_body(this, JJTINTERFACE_BODY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 8:
        case 19:
        case 30:
        case 45:
        case 46:
        case 47:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 63:
        case 67:
        case 68:
        case 71:
        case 72:
        case 73:
        case 74:
        case 75:
        case 81:
        case ID:
          ;
          break;
        default:
          jj_la1[9] = jj_gen;
          break label_3;
        }
        export();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 9: chater 3.4 CORBA 2.3.1, added pragma id inside */
  final public void export() throws ParseException {
 /*@bgen(jjtree) export */
  ASTexport jjtn000 = new ASTexport(this, JJTEXPORT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 45:
      case 46:
      case 58:
      case 59:
      case 63:
        type_dcl();
        jj_consume_token(11);
        break;
      case 30:
        const_dcl();
        jj_consume_token(11);
        break;
      case 73:
        except_dcl();
        jj_consume_token(11);
        break;
      case 71:
      case 72:
        attr_dcl();
        jj_consume_token(11);
        break;
      case 19:
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 67:
      case 68:
      case 74:
      case 75:
      case 81:
      case ID:
        op_dcl();
        jj_consume_token(11);
        break;
      case 8:
        pragmaIDInside();
        break;
      default:
        jj_la1[10] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 10: chapter 3.4 CORBA 2.3.1 */
  final public void interface_inheritance_spec() throws ParseException {
 /*@bgen(jjtree) interface_inheritance_spec */
  ASTinterface_inheritance_spec jjtn000 = new ASTinterface_inheritance_spec(this, JJTINTERFACE_INHERITANCE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(17);
      interface_name();
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[11] = jj_gen;
          break label_4;
        }
        jj_consume_token(18);
        interface_name();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 11: chapter 3.4, CORBA 2.3.1 */
  final public void interface_name() throws ParseException {
 /*@bgen(jjtree) interface_name */
  ASTinterface_name jjtn000 = new ASTinterface_name(this, JJTINTERFACE_NAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      scoped_name();
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 12: chapter 3.4, CORBA 2.3.1 */
  final public void scoped_name() throws ParseException {
 /*@bgen(jjtree) scoped_name */
  ASTscoped_name jjtn000 = new ASTscoped_name(this, JJTSCOPED_NAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String part = "";
  String fullScopedName = "";
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 19:
        jj_consume_token(19);
             fullScopedName = "::"; jjtn000.setHasFileScope(true);
        break;
      default:
        jj_la1[12] = jj_gen;
        ;
      }
      part = identifier();
                                                                                              fullScopedName += part; jjtn000.addNamePart(part);
      label_5:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 19:
          ;
          break;
        default:
          jj_la1[13] = jj_gen;
          break label_5;
        }
        jj_consume_token(19);
        part = identifier();
                                                                                                                                                                                fullScopedName += ("::" + part); jjtn000.addNamePart(part);
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.setScopedName(fullScopedName);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 13: TBD: check if correct */
  final public void value() throws ParseException {
 /*@bgen(jjtree) value */
  ASTvalue jjtn000 = new ASTvalue(this, JJTVALUE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_7(4)) {
        value_decl();
      } else if (jj_2_8(4)) {
        value_abs_decl();
      } else if (jj_2_9(4)) {
        value_box_decl();
      } else if (jj_2_10(4)) {
        value_forward_decl();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 14, chapter 3.4, CORBA 2.3.1 */
  final public void value_forward_decl() throws ParseException {
 /*@bgen(jjtree) value_forward_decl */
  ASTvalue_forward_decl jjtn000 = new ASTvalue_forward_decl(this, JJTVALUE_FORWARD_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
  boolean isAbstract = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 15:
        jj_consume_token(15);
                      isAbstract = true;
        break;
      default:
        jj_la1[14] = jj_gen;
        ;
      }
      jj_consume_token(20);
      ident = identifier();
      jj_consume_token(11);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setIdent(ident);
          jjtn000.setAbstract(isAbstract);
          Scope currentScope = m_symbolTable.getCurrentScope();
          currentScope.addFwdDecl(ident);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 15, chapter 3.4, CORBA 2.3.1 */
  final public void value_box_decl() throws ParseException {
 /*@bgen(jjtree) value_box_decl */
  ASTvalue_box_decl jjtn000 = new ASTvalue_box_decl(this, JJTVALUE_BOX_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(20);
      ident = identifier();
      type_spec();
      jj_consume_token(11);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
                jjtn000.setIdent(ident);
                // the symbol must not be added before the valuebox definition is completed, 3.8.2, CORBA 2.3.1 spec
            Scope currentScope = m_symbolTable.getCurrentScope();
            currentScope.addSymbol(ident);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 16, chapter 3.4, CORBA 2.3.1 */
  final public void value_abs_decl() throws ParseException {
 /*@bgen(jjtree) value_abs_decl */
  ASTvalue_abs_decl jjtn000 = new ASTvalue_abs_decl(this, JJTVALUE_ABS_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(15);
      jj_consume_token(20);
      ident = identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 17:
        value_base_inheritance_spec();
        break;
      default:
        jj_la1[15] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 23:
        value_support_inheritance_spec();
        break;
      default:
        jj_la1[16] = jj_gen;
        ;
      }
      jj_consume_token(13);
      label_6:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 8:
        case 19:
        case 30:
        case 45:
        case 46:
        case 47:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 63:
        case 67:
        case 68:
        case 71:
        case 72:
        case 73:
        case 74:
        case 75:
        case 81:
        case ID:
          ;
          break;
        default:
          jj_la1[17] = jj_gen;
          break label_6;
        }
        export();
      }
      jj_consume_token(14);
      jj_consume_token(11);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
        jjtn000.setIdent(ident);
      Scope currentScope = m_symbolTable.getCurrentScope();
      currentScope.addSymbol(ident);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 17, chapter 3.4, CORBA 2.3.1 */
  final public void value_decl() throws ParseException {
 /*@bgen(jjtree) value_decl */
  ASTvalue_decl jjtn000 = new ASTvalue_decl(this, JJTVALUE_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      value_header();
            // get the value header node
            SimpleNodeWithIdent header = (SimpleNodeWithIdent) jjtree.peekNode();
            // add the symbol for this value type to the symbol table
            Scope currentScope = m_symbolTable.getCurrentScope();
            currentScope.addSymbol(header.getIdent());
            m_symbolTable.openScope(header.getIdent()); // open a scope for type declaration inside this concrete value type

      jj_consume_token(13);
      label_7:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 8:
        case 19:
        case 24:
        case 25:
        case 26:
        case 30:
        case 45:
        case 46:
        case 47:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 63:
        case 67:
        case 68:
        case 71:
        case 72:
        case 73:
        case 74:
        case 75:
        case 81:
        case ID:
          ;
          break;
        default:
          jj_la1[18] = jj_gen;
          break label_7;
        }
        value_element();
      }
      jj_consume_token(14);
      jj_consume_token(11);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
            m_symbolTable.closeScope();
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 18, chapter 3.4, CORBA 2.3.1 */
  final public void value_header() throws ParseException {
 /*@bgen(jjtree) value_header */
  ASTvalue_header jjtn000 = new ASTvalue_header(this, JJTVALUE_HEADER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
  boolean isCustom = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 21:
        jj_consume_token(21);
                     isCustom = true;
        break;
      default:
        jj_la1[19] = jj_gen;
        ;
      }
      jj_consume_token(20);
      ident = identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 17:
        value_base_inheritance_spec();
        break;
      default:
        jj_la1[20] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 23:
        value_support_inheritance_spec();
        break;
      default:
        jj_la1[21] = jj_gen;
        ;
      }
                                                                                                                                                    jjtree.closeNodeScope(jjtn000, true);
                                                                                                                                                    jjtc000 = false;
                                                                                                                                                    jjtn000.setIdent(ident); jjtn000.setCustom(isCustom);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 19, chapter 3.4, CORBA 2.3.1, separated into two productions */
  final public void value_base_inheritance_spec() throws ParseException {
 /*@bgen(jjtree) value_base_inheritance_spec */
  ASTvalue_base_inheritance_spec jjtn000 = new ASTvalue_base_inheritance_spec(this, JJTVALUE_BASE_INHERITANCE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(17);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 22:
        jj_consume_token(22);
        break;
      default:
        jj_la1[22] = jj_gen;
        ;
      }
      value_name();
      label_8:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[23] = jj_gen;
          break label_8;
        }
        jj_consume_token(18);
        value_name();
      }
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

  final public void value_support_inheritance_spec() throws ParseException {
 /*@bgen(jjtree) value_support_inheritance_spec */
  ASTvalue_support_inheritance_spec jjtn000 = new ASTvalue_support_inheritance_spec(this, JJTVALUE_SUPPORT_INHERITANCE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(23);
      interface_name();
      label_9:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[24] = jj_gen;
          break label_9;
        }
        jj_consume_token(18);
        interface_name();
      }
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 20, chapter 3.4, CORBA 2.3.1 */
  final public void value_name() throws ParseException {
 /*@bgen(jjtree) value_name */
  ASTvalue_name jjtn000 = new ASTvalue_name(this, JJTVALUE_NAME);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      scoped_name();
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 21, chapter 3.4, CORBA 2.3.1 */
  final public void value_element() throws ParseException {
 /*@bgen(jjtree) value_element */
  ASTvalue_element jjtn000 = new ASTvalue_element(this, JJTVALUE_ELEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 8:
      case 19:
      case 30:
      case 45:
      case 46:
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 58:
      case 59:
      case 63:
      case 67:
      case 68:
      case 71:
      case 72:
      case 73:
      case 74:
      case 75:
      case 81:
      case ID:
        export();
        break;
      case 24:
      case 25:
        state_member();
        break;
      case 26:
        init_decl();
        break;
      default:
        jj_la1[25] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 22, chapter 3.4, CORBA 2.3.1 */
  final public void state_member() throws ParseException {
 /*@bgen(jjtree) state_member */
  ASTstate_member jjtn000 = new ASTstate_member(this, JJTSTATE_MEMBER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 24:
        jj_consume_token(24);
                     jjtn000.setIsPrivate(false);
        break;
      case 25:
        jj_consume_token(25);
                                                                  jjtn000.setIsPrivate(true);
        break;
      default:
        jj_la1[26] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      type_spec();
      declarators();
      jj_consume_token(11);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 23, chapter 3.4, CORBA 2.3.1 */
  final public void init_decl() throws ParseException {
 /*@bgen(jjtree) init_decl */
  ASTinit_decl jjtn000 = new ASTinit_decl(this, JJTINIT_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(26);
      ident = identifier();
      jj_consume_token(27);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 29:
        init_param_delcs();
        break;
      default:
        jj_la1[27] = jj_gen;
        ;
      }
      jj_consume_token(28);
      jj_consume_token(11);
                                                                            jjtree.closeNodeScope(jjtn000, true);
                                                                            jjtc000 = false;
                                                                            jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 24, chapter 3.4, CORBA 2.3.1 */
  final public void init_param_delcs() throws ParseException {
 /*@bgen(jjtree) init_param_delcs */
  ASTinit_param_delcs jjtn000 = new ASTinit_param_delcs(this, JJTINIT_PARAM_DELCS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      init_param_decl();
      label_10:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[28] = jj_gen;
          break label_10;
        }
        jj_consume_token(18);
        init_param_decl();
      }
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 25, chapter 3.4, CORBA 2.3.1 */
  final public void init_param_decl() throws ParseException {
 /*@bgen(jjtree) init_param_decl */
  ASTinit_param_decl jjtn000 = new ASTinit_param_decl(this, JJTINIT_PARAM_DECL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      init_param_attribute();
      param_type_spec();
      simple_declarator();
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 26, chapter 3.4, CORBA 2.3.1 */
  final public void init_param_attribute() throws ParseException {
 /*@bgen(jjtree) init_param_attribute */
  ASTinit_param_attribute jjtn000 = new ASTinit_param_attribute(this, JJTINIT_PARAM_ATTRIBUTE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(29);
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 27 chapter 3.4, corba 2.3.1 */
  final public void const_dcl() throws ParseException {
 /*@bgen(jjtree) const_dcl */
  ASTconst_dcl jjtn000 = new ASTconst_dcl(this, JJTCONST_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(30);
      const_type();
      ident = identifier();
      jj_consume_token(31);
      const_exp();
                                                              jjtree.closeNodeScope(jjtn000, true);
                                                              jjtc000 = false;
                                                              jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 28 chapter 3.4, corba 2.3.1 */
  final public void const_type() throws ParseException {
 /*@bgen(jjtree) const_type */
  ASTconst_type jjtn000 = new ASTconst_type(this, JJTCONST_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_11(2)) {
        integer_type();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 52:
          char_type();
          break;
        case 53:
          wide_char_type();
          break;
        case 54:
          boolean_type();
          break;
        case 47:
        case 48:
        case 49:
          floating_pt_type();
          break;
        case 67:
          string_type();
          break;
        case 68:
          wide_string_type();
          break;
        case 80:
          fixed_pt_const_type();
          break;
        case 19:
        case ID:
          scoped_name();
          break;
        case 55:
          octet_type();
          break;
        default:
          jj_la1[29] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 29 chapter 3.4, corba 2.3.1 */
  final public void const_exp() throws ParseException {
 /*@bgen(jjtree) const_exp */
  ASTconst_exp jjtn000 = new ASTconst_exp(this, JJTCONST_EXP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      or_expr();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 30 chapter 3.4 corba 2.3.1 (resolved left side recursion here) */
  final public void or_expr() throws ParseException {
 /*@bgen(jjtree) or_expr */
  ASTor_expr jjtn000 = new ASTor_expr(this, JJTOR_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      xor_expr();
      label_11:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 32:
          ;
          break;
        default:
          jj_la1[30] = jj_gen;
          break label_11;
        }
        jj_consume_token(32);
        xor_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 31 chapter 3.4 corba 2.3.1 (reformulated without recursion) */
  final public void xor_expr() throws ParseException {
 /*@bgen(jjtree) xor_expr */
  ASTxor_expr jjtn000 = new ASTxor_expr(this, JJTXOR_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      and_expr();
      label_12:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 33:
          ;
          break;
        default:
          jj_la1[31] = jj_gen;
          break label_12;
        }
        jj_consume_token(33);
        and_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 32 chapter 3.4 corba 2.3.1 (reformulated without recursion) */
  final public void and_expr() throws ParseException {
 /*@bgen(jjtree) and_expr */
  ASTand_expr jjtn000 = new ASTand_expr(this, JJTAND_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      shift_expr();
      label_13:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 34:
          ;
          break;
        default:
          jj_la1[32] = jj_gen;
          break label_13;
        }
        jj_consume_token(34);
        shift_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 33 */
  final public void shift_expr() throws ParseException {
 /*@bgen(jjtree) shift_expr */
  ASTshift_expr jjtn000 = new ASTshift_expr(this, JJTSHIFT_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      add_expr();
      label_14:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 35:
        case 36:
          ;
          break;
        default:
          jj_la1[33] = jj_gen;
          break label_14;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 35:
          jj_consume_token(35);
          break;
        case 36:
          jj_consume_token(36);
          break;
        default:
          jj_la1[34] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        add_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 34 */
  final public void add_expr() throws ParseException {
 /*@bgen(jjtree) add_expr */
  ASTadd_expr jjtn000 = new ASTadd_expr(this, JJTADD_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      mult_expr();
      label_15:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 37:
        case 38:
          ;
          break;
        default:
          jj_la1[35] = jj_gen;
          break label_15;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 37:
          jj_consume_token(37);
          break;
        case 38:
          jj_consume_token(38);
          break;
        default:
          jj_la1[36] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        mult_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 35 */
  final public void mult_expr() throws ParseException {
 /*@bgen(jjtree) mult_expr */
  ASTmult_expr jjtn000 = new ASTmult_expr(this, JJTMULT_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      unary_expr();
      label_16:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 39:
        case 40:
        case 41:
          ;
          break;
        default:
          jj_la1[37] = jj_gen;
          break label_16;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 39:
          jj_consume_token(39);
          break;
        case 40:
          jj_consume_token(40);
          break;
        case 41:
          jj_consume_token(41);
          break;
        default:
          jj_la1[38] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        unary_expr();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 36 */
  final public void unary_expr() throws ParseException {
 /*@bgen(jjtree) unary_expr */
  ASTunary_expr jjtn000 = new ASTunary_expr(this, JJTUNARY_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);int unary_op = ASTunary_expr.UNARY_NONE;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 37:
      case 38:
      case 42:
        unary_op = unary_operator();
        break;
      default:
        jj_la1[39] = jj_gen;
        ;
      }
      primary_expr();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 37 chapter 3.4 corba 2.3.1 */
  final public int unary_operator() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 38:
      jj_consume_token(38);
        {if (true) return ASTunary_expr.UNARY_MINUS;}
      break;
    case 37:
      jj_consume_token(37);
        {if (true) return ASTunary_expr.UNARY_PLUS;}
      break;
    case 42:
      jj_consume_token(42);
        {if (true) return ASTunary_expr.UNARY_NEGATE;}
      break;
    default:
      jj_la1[40] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

/* Production 38 chapter 3.4 corba 2.3.1 */
  final public void primary_expr() throws ParseException {
 /*@bgen(jjtree) primary_expr */
  ASTprimary_expr jjtn000 = new ASTprimary_expr(this, JJTPRIMARY_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 19:
      case ID:
        scoped_name();
        break;
      case 43:
      case 44:
      case 82:
      case 83:
      case OCTALINT:
      case DECIMALINT:
      case HEXADECIMALINT:
      case FLOATONE:
      case FLOATTWO:
      case CHARACTER:
      case STRING:
      case FIXED:
        literal();
        break;
      case 27:
        jj_consume_token(27);
        const_exp();
        jj_consume_token(28);
        break;
      default:
        jj_la1[41] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 39 chapter 3.4 corba 2.3.1 */
  final public void literal() throws ParseException {
 /*@bgen(jjtree) literal */
  ASTliteral jjtn000 = new ASTliteral(this, JJTLITERAL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);Object litVal;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OCTALINT:
      case DECIMALINT:
      case HEXADECIMALINT:
        litVal = integer_literal();
        break;
      case STRING:
        litVal = string_literal();
        break;
      default:
        jj_la1[42] = jj_gen;
        if (jj_2_12(2)) {
          litVal = wide_string_literal();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case CHARACTER:
            litVal = character_literal();
            break;
          default:
            jj_la1[43] = jj_gen;
            if (jj_2_13(2)) {
              litVal = wide_character_literal();
            } else {
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case 83:
              case FIXED:
                litVal = fixed_pt_literal();
                break;
              case FLOATONE:
              case FLOATTWO:
                litVal = floating_pt_literal();
                break;
              case 43:
              case 44:
                litVal = boolean_literal();
                break;
              default:
                jj_la1[44] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
              }
            }
          }
        }
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setLitVal(litVal);
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
  }
    }
  }

/* Production 40, chapter 3.4 corba 2.3.1 */
  final public Boolean boolean_literal() throws ParseException {
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case 43:
      jj_consume_token(43);
           {if (true) return new Boolean(true);}
      break;
    case 44:
      jj_consume_token(44);
            {if (true) return new Boolean(false);}
      break;
    default:
      jj_la1[45] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

/* Production 41, chapter 3.4, corba 2.3.1 */
  final public void positive_int_const() throws ParseException {
 /*@bgen(jjtree) positive_int_const */
  ASTpositive_int_const jjtn000 = new ASTpositive_int_const(this, JJTPOSITIVE_INT_CONST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      const_exp();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 42: chapter 3.4 corba 2.3.1 */
  final public void type_dcl() throws ParseException {
 /*@bgen(jjtree) type_dcl */
  ASTtype_dcl jjtn000 = new ASTtype_dcl(this, JJTTYPE_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 45:
        jj_consume_token(45);
        type_declarator();
        break;
      case 58:
        struct_type();
        break;
      case 59:
        union_type();
        break;
      case 63:
        enum_type();
        break;
      case 46:
        jj_consume_token(46);
        simple_declarator();
        break;
      default:
        jj_la1[46] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 43, chapter 3.4, corba 2.3.1 */
  final public void type_declarator() throws ParseException {
 /*@bgen(jjtree) type_declarator */
  ASTtype_declarator jjtn000 = new ASTtype_declarator(this, JJTTYPE_DECLARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      type_spec();
      declarators();
                              jjtree.closeNodeScope(jjtn000, true);
                              jjtc000 = false;
                Node declarators = jjtn000.jjtGetChild(1);
                Scope currentScope = m_symbolTable.getCurrentScope();
                for (int i = 0; i < declarators.jjtGetNumChildren(); i++) {
                    ASTdeclarator decl = (ASTdeclarator) declarators.jjtGetChild(i);
                    if (decl.jjtGetChild(0) instanceof ASTsimple_declarator) {
                            String ident = ((SimpleNodeWithIdent) decl.jjtGetChild(0)).getIdent();
                            currentScope.addTypeDef(ident);
                    }
                }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 44, chapter 3.4, corba 2.3.1 */
  final public void type_spec() throws ParseException {
 /*@bgen(jjtree) type_spec */
  ASTtype_spec jjtn000 = new ASTtype_spec(this, JJTTYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 19:
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 64:
      case 67:
      case 68:
      case 80:
      case 81:
      case ID:
        simple_type_spec();
        break;
      case 58:
      case 59:
      case 63:
        constr_type_spec();
        break;
      default:
        jj_la1[47] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 45, chapter 3.4, corba 2.3.1 */
  final public void simple_type_spec() throws ParseException {
 /*@bgen(jjtree) simple_type_spec */
  ASTsimple_type_spec jjtn000 = new ASTsimple_type_spec(this, JJTSIMPLE_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 81:
        base_type_spec();
        break;
      case 64:
      case 67:
      case 68:
      case 80:
        template_type_spec();
        break;
      case 19:
      case ID:
        scoped_name();
        break;
      default:
        jj_la1[48] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 46: chapter 3.4 corba 2.3.1 */
  final public void base_type_spec() throws ParseException {
 /*@bgen(jjtree) base_type_spec */
  ASTbase_type_spec jjtn000 = new ASTbase_type_spec(this, JJTBASE_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_14(2)) {
        floating_pt_type();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 49:
        case 50:
        case 51:
          integer_type();
          break;
        case 52:
          char_type();
          break;
        case 53:
          wide_char_type();
          break;
        case 54:
          boolean_type();
          break;
        case 55:
          octet_type();
          break;
        case 56:
          any_type();
          break;
        case 57:
          object_type();
          break;
        case 81:
          value_base_type();
          break;
        default:
          jj_la1[49] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 47: chapter 3.4 corba 2.3.1 */
  final public void template_type_spec() throws ParseException {
 /*@bgen(jjtree) template_type_spec */
  ASTtemplate_type_spec jjtn000 = new ASTtemplate_type_spec(this, JJTTEMPLATE_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 64:
        sequence_type();
        break;
      case 67:
        string_type();
        break;
      case 68:
        wide_string_type();
        break;
      case 80:
        fixed_pt_type();
        break;
      default:
        jj_la1[50] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 48, chapter 3.4, corba 2.3.1 */
  final public void constr_type_spec() throws ParseException {
 /*@bgen(jjtree) constr_type_spec */
  ASTconstr_type_spec jjtn000 = new ASTconstr_type_spec(this, JJTCONSTR_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 58:
        struct_type();
        break;
      case 59:
        union_type();
        break;
      case 63:
        enum_type();
        break;
      default:
        jj_la1[51] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 49, chapter 3.4, corba 2.3.1 */
  final public void declarators() throws ParseException {
 /*@bgen(jjtree) declarators */
  ASTdeclarators jjtn000 = new ASTdeclarators(this, JJTDECLARATORS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      declarator();
      label_17:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[52] = jj_gen;
          break label_17;
        }
        jj_consume_token(18);
        declarator();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 50, chapter 3.4, corba 2.3.1 */
  final public void declarator() throws ParseException {
 /*@bgen(jjtree) declarator */
  ASTdeclarator jjtn000 = new ASTdeclarator(this, JJTDECLARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_15(2)) {
        complex_declarator();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ID:
          simple_declarator();
          break;
        default:
          jj_la1[53] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 51, chapter 3.4, corba 2.3.1 */
  final public void simple_declarator() throws ParseException {
 /*@bgen(jjtree) simple_declarator */
  ASTsimple_declarator jjtn000 = new ASTsimple_declarator(this, JJTSIMPLE_DECLARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      ident = identifier();
                         jjtree.closeNodeScope(jjtn000, true);
                         jjtc000 = false;
                         jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 52, chapter 3.4, corba 2.3.1 */
  final public void complex_declarator() throws ParseException {
 /*@bgen(jjtree) complex_declarator */
  ASTcomplex_declarator jjtn000 = new ASTcomplex_declarator(this, JJTCOMPLEX_DECLARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      array_declarator();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 53, changed to the style used for int_types */
  final public void floating_pt_type() throws ParseException {
 /*@bgen(jjtree) floating_pt_type */
  ASTfloating_pt_type jjtn000 = new ASTfloating_pt_type(this, JJTFLOATING_PT_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 49:
        floating_pt_type_longdouble();
        break;
      case 47:
        floating_pt_type_float();
        break;
      case 48:
        floating_pt_type_double();
        break;
      default:
        jj_la1[54] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 53 a */
  final public void floating_pt_type_float() throws ParseException {
 /*@bgen(jjtree) floating_pt_type_float */
  ASTfloating_pt_type_float jjtn000 = new ASTfloating_pt_type_float(this, JJTFLOATING_PT_TYPE_FLOAT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(47);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 53 b */
  final public void floating_pt_type_double() throws ParseException {
 /*@bgen(jjtree) floating_pt_type_double */
  ASTfloating_pt_type_double jjtn000 = new ASTfloating_pt_type_double(this, JJTFLOATING_PT_TYPE_DOUBLE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(48);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 53 c */
  final public void floating_pt_type_longdouble() throws ParseException {
 /*@bgen(jjtree) floating_pt_type_longdouble */
  ASTfloating_pt_type_longdouble jjtn000 = new ASTfloating_pt_type_longdouble(this, JJTFLOATING_PT_TYPE_LONGDOUBLE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(49);
      jj_consume_token(48);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 54, chapter 3.4, corba 2.3.1 */
  final public void integer_type() throws ParseException {
 /*@bgen(jjtree) integer_type */
  ASTinteger_type jjtn000 = new ASTinteger_type(this, JJTINTEGER_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 49:
      case 50:
        signed_int();
        break;
      case 51:
        unsigned_int();
        break;
      default:
        jj_la1[55] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 55, chapter 3.4, corba 2.3.1 */
  final public void signed_int() throws ParseException {
 /*@bgen(jjtree) signed_int */
  ASTsigned_int jjtn000 = new ASTsigned_int(this, JJTSIGNED_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_16(3)) {
        signed_longlong_int();
      } else if (jj_2_17(3)) {
        signed_long_int();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 50:
          signed_short_int();
          break;
        default:
          jj_la1[56] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 56, chapter 3.4, corba 2.3.1 */
  final public void signed_short_int() throws ParseException {
 /*@bgen(jjtree) signed_short_int */
  ASTsigned_short_int jjtn000 = new ASTsigned_short_int(this, JJTSIGNED_SHORT_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(50);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 57, chapter 3.4, corba 2.3.1 */
  final public void signed_long_int() throws ParseException {
 /*@bgen(jjtree) signed_long_int */
  ASTsigned_long_int jjtn000 = new ASTsigned_long_int(this, JJTSIGNED_LONG_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(49);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 58, chapter 3.4, corba 2.3.1 */
  final public void signed_longlong_int() throws ParseException {
 /*@bgen(jjtree) signed_longlong_int */
  ASTsigned_longlong_int jjtn000 = new ASTsigned_longlong_int(this, JJTSIGNED_LONGLONG_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(49);
      jj_consume_token(49);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 59, chapter 3.4 corba 2.3.1 */
  final public void unsigned_int() throws ParseException {
 /*@bgen(jjtree) unsigned_int */
  ASTunsigned_int jjtn000 = new ASTunsigned_int(this, JJTUNSIGNED_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      if (jj_2_18(3)) {
        unsigned_longlong_int();
      } else if (jj_2_19(3)) {
        unsigned_long_int();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 51:
          unsigned_short_int();
          break;
        default:
          jj_la1[57] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 60, chapter 3.4, corba 2.3.1 */
  final public void unsigned_short_int() throws ParseException {
 /*@bgen(jjtree) unsigned_short_int */
  ASTunsigned_short_int jjtn000 = new ASTunsigned_short_int(this, JJTUNSIGNED_SHORT_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(51);
      jj_consume_token(50);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 61, chapter 3.4, corba 2.3.1 */
  final public void unsigned_long_int() throws ParseException {
 /*@bgen(jjtree) unsigned_long_int */
  ASTunsigned_long_int jjtn000 = new ASTunsigned_long_int(this, JJTUNSIGNED_LONG_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(51);
      jj_consume_token(49);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 62, chapter 3.4, corba 2.3.1 */
  final public void unsigned_longlong_int() throws ParseException {
 /*@bgen(jjtree) unsigned_longlong_int */
  ASTunsigned_longlong_int jjtn000 = new ASTunsigned_longlong_int(this, JJTUNSIGNED_LONGLONG_INT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(51);
      jj_consume_token(49);
      jj_consume_token(49);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 63, chapter 3.4, corba 2.3.1 */
  final public void char_type() throws ParseException {
 /*@bgen(jjtree) char_type */
  ASTchar_type jjtn000 = new ASTchar_type(this, JJTCHAR_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(52);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 64, chapter 3.4, corba 2.3.1 */
  final public void wide_char_type() throws ParseException {
 /*@bgen(jjtree) wide_char_type */
  ASTwide_char_type jjtn000 = new ASTwide_char_type(this, JJTWIDE_CHAR_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(53);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 65, chapter 3.4, corba 2.3.1  */
  final public void boolean_type() throws ParseException {
 /*@bgen(jjtree) boolean_type */
  ASTboolean_type jjtn000 = new ASTboolean_type(this, JJTBOOLEAN_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(54);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 66, chapter 3.4, corba 2.3.1 */
  final public void octet_type() throws ParseException {
 /*@bgen(jjtree) octet_type */
  ASToctet_type jjtn000 = new ASToctet_type(this, JJTOCTET_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(55);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 67, chapter 3.4, corba 2.3.1 */
  final public void any_type() throws ParseException {
 /*@bgen(jjtree) any_type */
  ASTany_type jjtn000 = new ASTany_type(this, JJTANY_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(56);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 68, chapter 3.4, corba 2.3.1 */
  final public void object_type() throws ParseException {
 /*@bgen(jjtree) object_type */
  ASTobject_type jjtn000 = new ASTobject_type(this, JJTOBJECT_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(57);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 69, chapter 3.4, corba 2.3.1 */
  final public void struct_type() throws ParseException {
 /*@bgen(jjtree) struct_type */
  ASTstruct_type jjtn000 = new ASTstruct_type(this, JJTSTRUCT_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(58);
      ident = identifier();
        // recursive definition using a sequence is permitted --> publish symbol already here
        Scope currentScope = m_symbolTable.getCurrentScope();
        currentScope.addSymbol(ident);
      jj_consume_token(13);
      member_list();
      jj_consume_token(14);
                          jjtree.closeNodeScope(jjtn000, true);
                          jjtc000 = false;
                          jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 70, chapter 3.4, corba 2.3.1 */
  final public void member_list() throws ParseException {
 /*@bgen(jjtree) member_list */
  ASTmember_list jjtn000 = new ASTmember_list(this, JJTMEMBER_LIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_18:
      while (true) {
        member();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 19:
        case 47:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 63:
        case 64:
        case 67:
        case 68:
        case 80:
        case 81:
        case ID:
          ;
          break;
        default:
          jj_la1[58] = jj_gen;
          break label_18;
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 71, chapter 3.4, corba 2.3.1 */
  final public void member() throws ParseException {
 /*@bgen(jjtree) member */
  ASTmember jjtn000 = new ASTmember(this, JJTMEMBER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      type_spec();
      declarators();
      jj_consume_token(11);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 72, chapter 3.4, corba 2.3.1 */
  final public void union_type() throws ParseException {
 /*@bgen(jjtree) union_type */
  ASTunion_type jjtn000 = new ASTunion_type(this, JJTUNION_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(59);
      ident = identifier();
      jj_consume_token(60);
      jj_consume_token(27);
      switch_type_spec();
      jj_consume_token(28);
      jj_consume_token(13);
      switch_body();
      jj_consume_token(14);
                                                                                           jjtree.closeNodeScope(jjtn000, true);
                                                                                           jjtc000 = false;
                                                                                           jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 73, chapter 3.4, corba 2.3.1 */
  final public void switch_type_spec() throws ParseException {
 /*@bgen(jjtree) switch_type_spec */
  ASTswitch_type_spec jjtn000 = new ASTswitch_type_spec(this, JJTSWITCH_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 49:
      case 50:
      case 51:
        integer_type();
        break;
      case 52:
        char_type();
        break;
      case 54:
        boolean_type();
        break;
      case 63:
        enum_type();
        break;
      case 19:
      case ID:
        scoped_name();
        break;
      default:
        jj_la1[59] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 74, chapter 3.4, corba 2.3.1 */
  final public void switch_body() throws ParseException {
 /*@bgen(jjtree) switch_body */
  ASTswitch_body jjtn000 = new ASTswitch_body(this, JJTSWITCH_BODY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_19:
      while (true) {
        casex();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 61:
        case 62:
          ;
          break;
        default:
          jj_la1[60] = jj_gen;
          break label_19;
        }
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 75, chapter 3.4, corba 2.3.1 (renamed case -> casex, because case is a keyword in java) */
  final public void casex() throws ParseException {
 /*@bgen(jjtree) casex */
  ASTcasex jjtn000 = new ASTcasex(this, JJTCASEX);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      label_20:
      while (true) {
        case_label();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 61:
        case 62:
          ;
          break;
        default:
          jj_la1[61] = jj_gen;
          break label_20;
        }
      }
      element_spec();
      jj_consume_token(11);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 76, chapter 3.4, corba 2.3.1 */
  final public void case_label() throws ParseException {
 /*@bgen(jjtree) case_label */
  ASTcase_label jjtn000 = new ASTcase_label(this, JJTCASE_LABEL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 61:
        jj_consume_token(61);
        const_exp();
        jj_consume_token(17);
        break;
      case 62:
        jj_consume_token(62);
        jj_consume_token(17);
        break;
      default:
        jj_la1[62] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 77, chapter 3.4, corba 2.3.1 */
  final public void element_spec() throws ParseException {
 /*@bgen(jjtree) element_spec */
  ASTelement_spec jjtn000 = new ASTelement_spec(this, JJTELEMENT_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      type_spec();
      declarator();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 78, chapter 3.4, corba 2.3.1 */
  final public void enum_type() throws ParseException {
 /*@bgen(jjtree) enum_type */
  ASTenum_type jjtn000 = new ASTenum_type(this, JJTENUM_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(63);
      ident = identifier();
      jj_consume_token(13);
      enumerator();
      label_21:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[63] = jj_gen;
          break label_21;
        }
        jj_consume_token(18);
        enumerator();
      }
      jj_consume_token(14);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
        jjtn000.setIdent(ident);
        Scope currentScope = m_symbolTable.getCurrentScope();
        currentScope.addSymbol(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 79, chapter 3.4, corba 2.3.1 */
  final public void enumerator() throws ParseException {
 /*@bgen(jjtree) enumerator */
  ASTenumerator jjtn000 = new ASTenumerator(this, JJTENUMERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      ident = identifier();
                         jjtree.closeNodeScope(jjtn000, true);
                         jjtc000 = false;
                         jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 80, chapter 3.4, corba 2.3.1 */
  final public void sequence_type() throws ParseException {
 /*@bgen(jjtree) sequence_type */
  ASTsequence_type jjtn000 = new ASTsequence_type(this, JJTSEQUENCE_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(64);
      jj_consume_token(65);
      simple_type_spec();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 18:
        jj_consume_token(18);
        positive_int_const();
        break;
      default:
        jj_la1[64] = jj_gen;
        ;
      }
      jj_consume_token(66);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 81, chapter 3.4, corba 2.3.1 */
  final public void string_type() throws ParseException {
 /*@bgen(jjtree) string_type */
  ASTstring_type jjtn000 = new ASTstring_type(this, JJTSTRING_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(67);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 65:
        jj_consume_token(65);
        positive_int_const();
        jj_consume_token(66);
        break;
      default:
        jj_la1[65] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 82, chapter 3.4, corba 2.3.1 */
  final public void wide_string_type() throws ParseException {
 /*@bgen(jjtree) wide_string_type */
  ASTwide_string_type jjtn000 = new ASTwide_string_type(this, JJTWIDE_STRING_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(68);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 65:
        jj_consume_token(65);
        positive_int_const();
        jj_consume_token(66);
        break;
      default:
        jj_la1[66] = jj_gen;
        ;
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 83, chapter 3.4, corba 2.3.1 */
  final public void array_declarator() throws ParseException {
 /*@bgen(jjtree) array_declarator */
  ASTarray_declarator jjtn000 = new ASTarray_declarator(this, JJTARRAY_DECLARATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      ident = identifier();
      label_22:
      while (true) {
        fixed_array_size();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 69:
          ;
          break;
        default:
          jj_la1[67] = jj_gen;
          break label_22;
        }
      }
                                                 jjtree.closeNodeScope(jjtn000, true);
                                                 jjtc000 = false;
                                                 jjtn000.setIdent(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 84, chapter 3.4, corba 2.3.1*/
  final public void fixed_array_size() throws ParseException {
 /*@bgen(jjtree) fixed_array_size */
  ASTfixed_array_size jjtn000 = new ASTfixed_array_size(this, JJTFIXED_ARRAY_SIZE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(69);
      positive_int_const();
      jj_consume_token(70);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 85, chapter 3.4, corba 2.3.1 */
  final public void attr_dcl() throws ParseException {
 /*@bgen(jjtree) attr_dcl */
  ASTattr_dcl jjtn000 = new ASTattr_dcl(this, JJTATTR_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);boolean isReadOnly = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 71:
        jj_consume_token(71);
                 isReadOnly = true;
        break;
      default:
        jj_la1[68] = jj_gen;
        ;
      }
      jj_consume_token(72);
      param_type_spec();
      simple_declarator();
      label_23:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[69] = jj_gen;
          break label_23;
        }
        jj_consume_token(18);
        simple_declarator();
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setReadOnly(isReadOnly);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 86, chapter 3.4, corba 2.3.1 */
  final public void except_dcl() throws ParseException {
 /*@bgen(jjtree) except_dcl */
  ASTexcept_dcl jjtn000 = new ASTexcept_dcl(this, JJTEXCEPT_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
    try {
      jj_consume_token(73);
      ident = identifier();
      jj_consume_token(13);
      label_24:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 19:
        case 47:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 63:
        case 64:
        case 67:
        case 68:
        case 80:
        case 81:
        case ID:
          ;
          break;
        default:
          jj_la1[70] = jj_gen;
          break label_24;
        }
        member();
      }
      jj_consume_token(14);
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
        jjtn000.setIdent(ident);
        Scope currentScope = m_symbolTable.getCurrentScope();
        currentScope.addSymbol(ident);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 87, chapter 3.4, corba 2.3.1 */
  final public void op_dcl() throws ParseException {
 /*@bgen(jjtree) op_dcl */
  ASTop_dcl jjtn000 = new ASTop_dcl(this, JJTOP_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String ident = "";
  int opAttr = ASTop_dcl.OP_Attr_NONE;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 74:
        opAttr = op_attribute();
        break;
      default:
        jj_la1[71] = jj_gen;
        ;
      }
      op_type_spec();
      ident = identifier();
      parameter_dcls();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 78:
        raises_expr();
        break;
      default:
        jj_la1[72] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 79:
        context_expr();
        break;
      default:
        jj_la1[73] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.setIdent(ident); /* set the identifier for this node */
    jjtn000.setOpAttr(opAttr);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 88, chapter 3.4, corba 2.3.1 */
  final public int op_attribute() throws ParseException {
    jj_consume_token(74);
             {if (true) return ASTop_dcl.OP_Attr_ONEWAY;}
    throw new Error("Missing return statement in function");
  }

/* Production 89, chapter 3.4, corba 2.3.1 */
  final public void op_type_spec() throws ParseException {
 /*@bgen(jjtree) op_type_spec */
  ASTop_type_spec jjtn000 = new ASTop_type_spec(this, JJTOP_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 19:
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 67:
      case 68:
      case 81:
      case ID:
        param_type_spec();
        break;
      case 75:
        jj_consume_token(75);
        break;
      default:
        jj_la1[74] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 90, chapter 3.4, corba 2.3.1 */
  final public void parameter_dcls() throws ParseException {
 /*@bgen(jjtree) parameter_dcls */
  ASTparameter_dcls jjtn000 = new ASTparameter_dcls(this, JJTPARAMETER_DCLS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(27);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 29:
      case 76:
      case 77:
        param_dcl();
        label_25:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case 18:
            ;
            break;
          default:
            jj_la1[75] = jj_gen;
            break label_25;
          }
          jj_consume_token(18);
          param_dcl();
        }
        break;
      default:
        jj_la1[76] = jj_gen;
        ;
      }
      jj_consume_token(28);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 91, chapter 3.4, corba 2.3.1 */
  final public void param_dcl() throws ParseException {
 /*@bgen(jjtree) param_dcl */
  ASTparam_dcl jjtn000 = new ASTparam_dcl(this, JJTPARAM_DCL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      param_attribute();
      param_type_spec();
      simple_declarator();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 92, chapter 3.4, corba 2.3.1 */
  final public void param_attribute() throws ParseException {
 /*@bgen(jjtree) param_attribute */
  ASTparam_attribute jjtn000 = new ASTparam_attribute(this, JJTPARAM_ATTRIBUTE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 29:
        jj_consume_token(29);
         jjtree.closeNodeScope(jjtn000, true);
         jjtc000 = false;
         jjtn000.setParamDir(ASTparam_attribute.ParamDir_IN);
        break;
      case 76:
        jj_consume_token(76);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.setParamDir(ASTparam_attribute.ParamDir_OUT);
        break;
      case 77:
        jj_consume_token(77);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setParamDir(ASTparam_attribute.ParamDir_INOUT);
        break;
      default:
        jj_la1[77] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 93, chapter 3.4, corba 2.3.1 */
  final public void raises_expr() throws ParseException {
 /*@bgen(jjtree) raises_expr */
  ASTraises_expr jjtn000 = new ASTraises_expr(this, JJTRAISES_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(78);
      jj_consume_token(27);
      scoped_name();
      label_26:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[78] = jj_gen;
          break label_26;
        }
        jj_consume_token(18);
        scoped_name();
      }
      jj_consume_token(28);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 94, chapter 3.4, corba 2.3.1 */
  final public void context_expr() throws ParseException {
 /*@bgen(jjtree) context_expr */
  ASTcontext_expr jjtn000 = new ASTcontext_expr(this, JJTCONTEXT_EXPR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);String contElem = "";
    try {
      jj_consume_token(79);
      jj_consume_token(27);
      contElem = string_literal();
                                              jjtn000.addContextElement(contElem);
      label_27:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 18:
          ;
          break;
        default:
          jj_la1[79] = jj_gen;
          break label_27;
        }
        jj_consume_token(18);
        contElem = string_literal();
                                      jjtn000.addContextElement(contElem);
      }
      jj_consume_token(28);
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 95, chapter 3.4, corba 2.3.1 */
  final public void param_type_spec() throws ParseException {
 /*@bgen(jjtree) param_type_spec */
  ASTparam_type_spec jjtn000 = new ASTparam_type_spec(this, JJTPARAM_TYPE_SPEC);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 47:
      case 48:
      case 49:
      case 50:
      case 51:
      case 52:
      case 53:
      case 54:
      case 55:
      case 56:
      case 57:
      case 81:
        base_type_spec();
        break;
      case 67:
        string_type();
        break;
      case 68:
        wide_string_type();
        break;
      case 19:
      case ID:
        scoped_name();
        break;
      default:
        jj_la1[80] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

/* Production 96, chapter 3.4, corba 2.3.1 */
  final public void fixed_pt_type() throws ParseException {
 /*@bgen(jjtree) fixed_pt_type */
  ASTfixed_pt_type jjtn000 = new ASTfixed_pt_type(this, JJTFIXED_PT_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(80);
      jj_consume_token(65);
      positive_int_const();
      jj_consume_token(18);
      positive_int_const();
      jj_consume_token(66);
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 97, chapter 3.4, corba 2.3.1 */
  final public void fixed_pt_const_type() throws ParseException {
 /*@bgen(jjtree) fixed_pt_const_type */
  ASTfixed_pt_const_type jjtn000 = new ASTfixed_pt_const_type(this, JJTFIXED_PT_CONST_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(80);
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Production 98, chapter 3.4, corba 2.3.1 */
  final public void value_base_type() throws ParseException {
 /*@bgen(jjtree) value_base_type */
  ASTvalue_base_type jjtn000 = new ASTvalue_base_type(this, JJTVALUE_BASE_TYPE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(81);
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
          }
    }
  }

/* Definitions of complex regular expressions follow */
  final public String identifier() throws ParseException {
  Token idToken;
    idToken = jj_consume_token(ID);
                   {if (true) return idToken.image;}
    throw new Error("Missing return statement in function");
  }

  final public Long integer_literal() throws ParseException {
  Token intToken;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OCTALINT:
      intToken = jj_consume_token(OCTALINT);
                                                                String octVal = intToken.image;
                                                                // remove leading 0
                                                                octVal = octVal.substring(1);
                                                                // check for l, L, u, U at the end
                                                                if (octVal.endsWith("l") || octVal.endsWith("L") || octVal.endsWith("u") || octVal.endsWith("U")) {
                                                                        octVal = octVal.substring(0, octVal.length()-1); // remove u, U, L, l
                                                                }
                                                                {if (true) return new Long(Long.parseLong(octVal, 8));}
      break;
    case DECIMALINT:
      intToken = jj_consume_token(DECIMALINT);
                                                                String val = intToken.image;
                                                                // check for l, L, u, U at the end
                                                                if (val.endsWith("l") || val.endsWith("L") || val.endsWith("u") || val.endsWith("U")) {
                                                                        val = val.substring(0, val.length()-1); // remove u, U, L, l
                                                                }
                                                                {if (true) return new Long(Long.parseLong(val, 10));}
      break;
    case HEXADECIMALINT:
      intToken = jj_consume_token(HEXADECIMALINT);
                                                        String hexVal = intToken.image;
                                                                // remove leading 0x
                                                                hexVal = hexVal.substring(2);
                                                                // check for l, L, u, U at the end
                                                                if (hexVal.endsWith("l") || hexVal.endsWith("L") || hexVal.endsWith("u") || hexVal.endsWith("U")) {
                                                                        hexVal = hexVal.substring(0, hexVal.length()-1); // remove u, U, L, l
                                                                }
                                                                {if (true) return new Long(Long.parseLong(hexVal, 16));}
      break;
    default:
      jj_la1[81] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public String string_literal() throws ParseException {
  Token stringToken;
    stringToken = jj_consume_token(STRING);
                                                                        String result = stringToken.image;
                                                                        // remove "" around the literal
                                                                        {if (true) return result.substring(1, result.length() - 1);}
    throw new Error("Missing return statement in function");
  }

  final public String wide_string_literal() throws ParseException {
  Token stringToken;
    jj_consume_token(82);
    stringToken = jj_consume_token(STRING);
                                                                        String result = stringToken.image;
                                                                        // remove "" around the literal
                                                                        {if (true) return result.substring(1, result.length() - 1);}
    throw new Error("Missing return statement in function");
  }

  final public Character character_literal() throws ParseException {
  Token charToken;
    charToken = jj_consume_token(CHARACTER);
                                                                // TBD: not correct: escaped chars
                                                                char val = charToken.image.charAt(1);
                                                                {if (true) return new Character(val);}
    throw new Error("Missing return statement in function");
  }

  final public Character wide_character_literal() throws ParseException {
  Token charToken;
    jj_consume_token(82);
    charToken = jj_consume_token(CHARACTER);
                                                                 // TBD: not correct: escaped chars
                                                                 char val = charToken.image.charAt(1);
                                                                 {if (true) return new Character(val);}
    throw new Error("Missing return statement in function");
  }

  final public Float floating_pt_literal() throws ParseException {
  Token floatLiteral;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case FLOATONE:
      floatLiteral = jj_consume_token(FLOATONE);
      break;
    case FLOATTWO:
      floatLiteral = jj_consume_token(FLOATTWO);
      break;
    default:
      jj_la1[82] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
          String floatVal = floatLiteral.image;
      if (floatVal.endsWith("f") || floatVal.endsWith("F") || floatVal.endsWith("l") || floatVal.endsWith("L")) {
        floatVal = floatVal.substring(0, floatVal.length() - 1);
      }
      {if (true) return new Float(floatVal);}
    throw new Error("Missing return statement in function");
  }

  final public java.math.BigDecimal fixed_pt_literal() throws ParseException {
  Token fixedLiteral;
    if (jj_2_20(2147483647)) {
      fixedLiteral = jj_consume_token(FIXED);
      jj_consume_token(83);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FIXED:
        jj_consume_token(FIXED);
        break;
      default:
        jj_la1[83] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 84:
        jj_consume_token(84);
        break;
      case 85:
        jj_consume_token(85);
        break;
      default:
        jj_la1[84] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } else {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 83:
        fixedLiteral = jj_consume_token(83);
        jj_consume_token(FIXED);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 84:
          jj_consume_token(84);
          break;
        case 85:
          jj_consume_token(85);
          break;
        default:
          jj_la1[85] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case FIXED:
        fixedLiteral = jj_consume_token(FIXED);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case 84:
          jj_consume_token(84);
          break;
        case 85:
          jj_consume_token(85);
          break;
        default:
          jj_la1[86] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[87] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    }
        String fixedVal = fixedLiteral.image;
        if (fixedVal.endsWith("d") || fixedVal.endsWith("D")) {
                fixedVal = fixedVal.substring(0, fixedVal.length() - 1);
        }
        {if (true) return new java.math.BigDecimal(fixedVal);}
    throw new Error("Missing return statement in function");
  }

  final private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_1();
    jj_save(0, xla);
    return retval;
  }

  final private boolean jj_2_2(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_2();
    jj_save(1, xla);
    return retval;
  }

  final private boolean jj_2_3(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_3();
    jj_save(2, xla);
    return retval;
  }

  final private boolean jj_2_4(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_4();
    jj_save(3, xla);
    return retval;
  }

  final private boolean jj_2_5(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_5();
    jj_save(4, xla);
    return retval;
  }

  final private boolean jj_2_6(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_6();
    jj_save(5, xla);
    return retval;
  }

  final private boolean jj_2_7(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_7();
    jj_save(6, xla);
    return retval;
  }

  final private boolean jj_2_8(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_8();
    jj_save(7, xla);
    return retval;
  }

  final private boolean jj_2_9(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_9();
    jj_save(8, xla);
    return retval;
  }

  final private boolean jj_2_10(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_10();
    jj_save(9, xla);
    return retval;
  }

  final private boolean jj_2_11(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_11();
    jj_save(10, xla);
    return retval;
  }

  final private boolean jj_2_12(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_12();
    jj_save(11, xla);
    return retval;
  }

  final private boolean jj_2_13(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_13();
    jj_save(12, xla);
    return retval;
  }

  final private boolean jj_2_14(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_14();
    jj_save(13, xla);
    return retval;
  }

  final private boolean jj_2_15(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_15();
    jj_save(14, xla);
    return retval;
  }

  final private boolean jj_2_16(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_16();
    jj_save(15, xla);
    return retval;
  }

  final private boolean jj_2_17(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_17();
    jj_save(16, xla);
    return retval;
  }

  final private boolean jj_2_18(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_18();
    jj_save(17, xla);
    return retval;
  }

  final private boolean jj_2_19(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_19();
    jj_save(18, xla);
    return retval;
  }

  final private boolean jj_2_20(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    boolean retval = !jj_3_20();
    jj_save(19, xla);
    return retval;
  }

  final private boolean jj_3R_156() {
    if (jj_3R_171()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_35() {
    if (jj_scan_token(15)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(20)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_58()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    xsp = jj_scanpos;
    if (jj_3R_59()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(13)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_148() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_156()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_157()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_136() {
    if (jj_3R_109()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_135() {
    if (jj_3R_108()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_102() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_134()) {
    jj_scanpos = xsp;
    if (jj_3R_135()) {
    jj_scanpos = xsp;
    if (jj_3R_136()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_134() {
    if (jj_3R_107()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_36() {
    if (jj_scan_token(20)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_60()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(11)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_70() {
    if (jj_scan_token(73)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_169() {
    if (jj_3R_178()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_89() {
    if (jj_3R_105()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_168() {
    if (jj_3R_143()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_167() {
    if (jj_3R_142()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_155() {
    if (jj_scan_token(71)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_166() {
    if (jj_3R_177()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_153() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_166()) {
    jj_scanpos = xsp;
    if (jj_3R_167()) {
    jj_scanpos = xsp;
    if (jj_3R_168()) {
    jj_scanpos = xsp;
    if (jj_3R_169()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_147() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_155()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(72)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_61() {
    if (jj_scan_token(15)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_37() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_61()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(20)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(11)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_165() {
    if (jj_3R_176()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_105() {
    if (jj_scan_token(69)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_164() {
    if (jj_3R_175()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_163() {
    if (jj_3R_174()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_181() {
    if (jj_scan_token(65)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_162() {
    if (jj_3R_146()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_161() {
    if (jj_3R_141()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_10() {
    if (jj_3R_37()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_67() {
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    if (jj_3R_89()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_89()) { jj_scanpos = xsp; break; }
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    }
    return false;
  }

  final private boolean jj_3R_160() {
    if (jj_3R_140()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_9() {
    if (jj_3R_36()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_159() {
    if (jj_3R_139()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_180() {
    if (jj_scan_token(65)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_158() {
    if (jj_3R_38()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_8() {
    if (jj_3R_35()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_74() {
    if (jj_3R_96()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_152() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_14()) {
    jj_scanpos = xsp;
    if (jj_3R_158()) {
    jj_scanpos = xsp;
    if (jj_3R_159()) {
    jj_scanpos = xsp;
    if (jj_3R_160()) {
    jj_scanpos = xsp;
    if (jj_3R_161()) {
    jj_scanpos = xsp;
    if (jj_3R_162()) {
    jj_scanpos = xsp;
    if (jj_3R_163()) {
    jj_scanpos = xsp;
    if (jj_3R_164()) {
    jj_scanpos = xsp;
    if (jj_3R_165()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_7() {
    if (jj_3R_34()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_31() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_7()) {
    jj_scanpos = xsp;
    if (jj_3_8()) {
    jj_scanpos = xsp;
    if (jj_3_9()) {
    jj_scanpos = xsp;
    if (jj_3_10()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_14() {
    if (jj_3R_41()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_143() {
    if (jj_scan_token(68)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_181()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_133() {
    if (jj_3R_145()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_142() {
    if (jj_scan_token(67)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_180()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_132() {
    if (jj_3R_153()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_101() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_131()) {
    jj_scanpos = xsp;
    if (jj_3R_132()) {
    jj_scanpos = xsp;
    if (jj_3R_133()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_131() {
    if (jj_3R_152()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_154() {
    if (jj_scan_token(19)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_177() {
    if (jj_scan_token(64)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(65)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_145() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_154()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_170()) { jj_scanpos = xsp; break; }
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    }
    return false;
  }

  final private boolean jj_3R_83() {
    if (jj_3R_102()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_120() {
    if (jj_3R_145()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_60() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_82()) {
    jj_scanpos = xsp;
    if (jj_3R_83()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_82() {
    if (jj_3R_101()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_96() {
    if (jj_scan_token(17)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_120()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_109() {
    if (jj_scan_token(63)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_106() {
    if (jj_3R_60()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_126() {
    if (jj_3R_149()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_125() {
    if (jj_3R_148()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_94() {
    if (jj_scan_token(46)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_110()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_124() {
    if (jj_3R_147()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_93() {
    if (jj_3R_109()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_123() {
    if (jj_3R_70()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_92() {
    if (jj_3R_108()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_122() {
    if (jj_3R_69()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_91() {
    if (jj_3R_107()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_97() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_121()) {
    jj_scanpos = xsp;
    if (jj_3R_122()) {
    jj_scanpos = xsp;
    if (jj_3R_123()) {
    jj_scanpos = xsp;
    if (jj_3R_124()) {
    jj_scanpos = xsp;
    if (jj_3R_125()) {
    jj_scanpos = xsp;
    if (jj_3R_126()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_121() {
    if (jj_3R_68()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_68() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_90()) {
    jj_scanpos = xsp;
    if (jj_3R_91()) {
    jj_scanpos = xsp;
    if (jj_3R_92()) {
    jj_scanpos = xsp;
    if (jj_3R_93()) {
    jj_scanpos = xsp;
    if (jj_3R_94()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_90() {
    if (jj_scan_token(45)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_106()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_75() {
    if (jj_3R_97()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_53() {
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_75()) { jj_scanpos = xsp; break; }
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    }
    return false;
  }

  final private boolean jj_3R_73() {
    if (jj_scan_token(15)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_52() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_73()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(16)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    xsp = jj_scanpos;
    if (jj_3R_74()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_54() {
    if (jj_scan_token(15)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_33() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_54()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(16)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_13() {
    if (jj_3R_40()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_12() {
    if (jj_3R_39()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_108() {
    if (jj_scan_token(59)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_20() {
    if (jj_scan_token(FIXED)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(83)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_32() {
    if (jj_3R_52()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(13)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_53()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(14)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_6() {
    if (jj_3R_33()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_5() {
    if (jj_3R_32()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_30() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_5()) {
    jj_scanpos = xsp;
    if (jj_3_6()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_107() {
    if (jj_scan_token(58)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_175() {
    if (jj_scan_token(57)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_71() {
    if (jj_scan_token(12)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_174() {
    if (jj_scan_token(56)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_51() {
    if (jj_3R_72()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_4() {
    if (jj_3R_31()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_40() {
    if (jj_scan_token(82)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(CHARACTER)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_146() {
    if (jj_scan_token(55)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_50() {
    if (jj_3R_71()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_3() {
    if (jj_3R_30()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_49() {
    if (jj_3R_70()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_48() {
    if (jj_3R_69()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_141() {
    if (jj_scan_token(54)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_47() {
    if (jj_3R_68()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_28() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_47()) {
    jj_scanpos = xsp;
    if (jj_3R_48()) {
    jj_scanpos = xsp;
    if (jj_3R_49()) {
    jj_scanpos = xsp;
    if (jj_3_3()) {
    jj_scanpos = xsp;
    if (jj_3R_50()) {
    jj_scanpos = xsp;
    if (jj_3_4()) {
    jj_scanpos = xsp;
    if (jj_3R_51()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_140() {
    if (jj_scan_token(53)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_39() {
    if (jj_scan_token(82)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(STRING)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_2() {
    if (jj_3R_29()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_1() {
    if (jj_3R_28()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_139() {
    if (jj_scan_token(52)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_45() {
    if (jj_scan_token(51)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_46() {
    if (jj_scan_token(51)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_78() {
    if (jj_3R_81()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_119() {
    if (jj_3R_146()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_118() {
    if (jj_3R_145()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_138() {
    if (jj_scan_token(51)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(50)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_117() {
    if (jj_3R_144()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_116() {
    if (jj_3R_143()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_115() {
    if (jj_3R_142()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_114() {
    if (jj_3R_41()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_113() {
    if (jj_3R_141()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_104() {
    if (jj_3R_138()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_112() {
    if (jj_3R_140()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_151() {
    if (jj_scan_token(25)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_19() {
    if (jj_3R_46()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_111() {
    if (jj_3R_139()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_18() {
    if (jj_3R_45()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_85() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_18()) {
    jj_scanpos = xsp;
    if (jj_3_19()) {
    jj_scanpos = xsp;
    if (jj_3R_104()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_11() {
    if (jj_3R_38()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_95() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_11()) {
    jj_scanpos = xsp;
    if (jj_3R_111()) {
    jj_scanpos = xsp;
    if (jj_3R_112()) {
    jj_scanpos = xsp;
    if (jj_3R_113()) {
    jj_scanpos = xsp;
    if (jj_3R_114()) {
    jj_scanpos = xsp;
    if (jj_3R_115()) {
    jj_scanpos = xsp;
    if (jj_3R_116()) {
    jj_scanpos = xsp;
    if (jj_3R_117()) {
    jj_scanpos = xsp;
    if (jj_3R_118()) {
    jj_scanpos = xsp;
    if (jj_3R_119()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_29() {
    if (jj_scan_token(8)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(10)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_55() {
    if (jj_scan_token(ID)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_69() {
    if (jj_scan_token(30)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_95()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_43() {
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_176() {
    if (jj_scan_token(81)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_77() {
    if (jj_3R_80()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_44() {
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_144() {
    if (jj_scan_token(80)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_149() {
    if (jj_scan_token(8)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_137() {
    if (jj_scan_token(50)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_178() {
    if (jj_scan_token(80)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(65)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_130() {
    if (jj_scan_token(26)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_103() {
    if (jj_3R_137()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_17() {
    if (jj_3R_44()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_170() {
    if (jj_scan_token(19)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_59() {
    if (jj_3R_81()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_150() {
    if (jj_scan_token(24)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_185() {
    if (jj_3R_145()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_72() {
    if (jj_scan_token(8)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(9)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_16() {
    if (jj_3R_43()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_84() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3_16()) {
    jj_scanpos = xsp;
    if (jj_3_17()) {
    jj_scanpos = xsp;
    if (jj_3R_103()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_129() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_150()) {
    jj_scanpos = xsp;
    if (jj_3R_151()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_184() {
    if (jj_3R_143()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_183() {
    if (jj_3R_142()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_182() {
    if (jj_3R_152()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_179() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_182()) {
    jj_scanpos = xsp;
    if (jj_3R_183()) {
    jj_scanpos = xsp;
    if (jj_3R_184()) {
    jj_scanpos = xsp;
    if (jj_3R_185()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_63() {
    if (jj_3R_85()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_100() {
    if (jj_3R_130()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_62() {
    if (jj_3R_84()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_38() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_62()) {
    jj_scanpos = xsp;
    if (jj_3R_63()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_99() {
    if (jj_3R_129()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_79() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_98()) {
    jj_scanpos = xsp;
    if (jj_3R_99()) {
    jj_scanpos = xsp;
    if (jj_3R_100()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_98() {
    if (jj_3R_97()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_86() {
    if (jj_scan_token(49)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(48)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_128() {
    if (jj_3R_145()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_88() {
    if (jj_scan_token(48)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_81() {
    if (jj_scan_token(23)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_120()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_127() {
    if (jj_scan_token(22)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_87() {
    if (jj_scan_token(47)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_58() {
    if (jj_3R_80()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_80() {
    if (jj_scan_token(17)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_127()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_128()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_66() {
    if (jj_3R_88()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_65() {
    if (jj_3R_87()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_76() {
    if (jj_scan_token(21)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_64() {
    if (jj_3R_86()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_41() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_64()) {
    jj_scanpos = xsp;
    if (jj_3R_65()) {
    jj_scanpos = xsp;
    if (jj_3R_66()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_56() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_76()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(20)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    xsp = jj_scanpos;
    if (jj_3R_77()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    xsp = jj_scanpos;
    if (jj_3R_78()) jj_scanpos = xsp;
    else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_57() {
    if (jj_3R_79()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_42() {
    if (jj_3R_67()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_110() {
    if (jj_3R_55()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_173() {
    if (jj_scan_token(75)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_172() {
    if (jj_3R_179()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_157() {
    Token xsp;
    xsp = jj_scanpos;
    if (jj_3R_172()) {
    jj_scanpos = xsp;
    if (jj_3R_173()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    } else if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_34() {
    if (jj_3R_56()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    if (jj_scan_token(13)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    Token xsp;
    while (true) {
      xsp = jj_scanpos;
      if (jj_3R_57()) { jj_scanpos = xsp; break; }
      if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    }
    if (jj_scan_token(14)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3R_171() {
    if (jj_scan_token(74)) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  final private boolean jj_3_15() {
    if (jj_3R_42()) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) return false;
    return false;
  }

  public IDLParserTokenManager token_source;
  JavaCharStream jj_input_stream;
  public Token token, jj_nt;
  private int jj_ntk;
  private Token jj_scanpos, jj_lastpos;
  private int jj_la;
  public boolean lookingAhead = false;
  private boolean jj_semLA;
  private int jj_gen;
  final private int[] jj_la1 = new int[88];
  final private int[] jj_la1_0 = {0x40319100,0x40319101,0x40000000,0x1000,0x100,0x40319100,0x8000,0x8000,0x20000,0x40080100,0x40080100,0x40000,0x80000,0x80000,0x8000,0x20000,0x800000,0x40080100,0x47080100,0x200000,0x20000,0x800000,0x400000,0x40000,0x40000,0x47080100,0x3000000,0x20000000,0x40000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8080000,0x0,0x0,0x0,0x0,0x0,0x80000,0x80000,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x80000,0x80000,0x0,0x0,0x0,0x40000,0x40000,0x0,0x0,0x0,0x0,0x40000,0x80000,0x0,0x0,0x0,0x80000,0x40000,0x20000000,0x20000000,0x40000,0x40000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
  final private int[] jj_la1_1 = {0x8c006000,0x8c006000,0x8c006000,0x0,0x0,0x8c006000,0x0,0x0,0x0,0x8fffe000,0x8fffe000,0x0,0x0,0x0,0x0,0x0,0x0,0x8fffe000,0x8fffe000,0x0,0x0,0x0,0x0,0x0,0x0,0x8fffe000,0x0,0x0,0x0,0xf38000,0x1,0x2,0x4,0x18,0x18,0x60,0x60,0x380,0x380,0x460,0x460,0x1800,0x0,0x0,0x1800,0x1800,0x8c006000,0x8fff8000,0x3ff8000,0x3fe0000,0x0,0x8c000000,0x0,0x0,0x38000,0xe0000,0x40000,0x80000,0x8fff8000,0x805e0000,0x60000000,0x60000000,0x60000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8fff8000,0x0,0x0,0x0,0x3ff8000,0x0,0x0,0x0,0x0,0x0,0x3ff8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
  final private int[] jj_la1_2 = {0x200,0x200,0x200,0x0,0x0,0x200,0x0,0x0,0x0,0x420f98,0x420f98,0x0,0x0,0x0,0x0,0x0,0x0,0x420f98,0x420f98,0x0,0x0,0x0,0x0,0x0,0x0,0x420f98,0x0,0x0,0x0,0x410018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fcc0000,0x23800000,0x10000000,0x4c080000,0x0,0x0,0x430019,0x430019,0x20000,0x10019,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x430019,0x400000,0x0,0x0,0x0,0x0,0x0,0x2,0x2,0x20,0x80,0x0,0x430019,0x400,0x4000,0x8000,0x420818,0x0,0x3000,0x3000,0x0,0x0,0x420018,0x3800000,0xc000000,0x40000000,0x300000,0x300000,0x300000,0x40080000,};
  final private JJCalls[] jj_2_rtns = new JJCalls[20];
  private boolean jj_rescan = false;
  private int jj_gc = 0;

  public IDLParser(java.io.InputStream stream) {
    jj_input_stream = new JavaCharStream(stream, 1, 1);
    token_source = new IDLParserTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(java.io.InputStream stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public IDLParser(java.io.Reader stream) {
    jj_input_stream = new JavaCharStream(stream, 1, 1);
    token_source = new IDLParserTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public IDLParser(IDLParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  public void ReInit(IDLParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 88; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  final private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  final private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    return (jj_scanpos.kind != kind);
  }

  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

  final public Token getToken(int index) {
    Token t = lookingAhead ? jj_scanpos : token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  final private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.Vector jj_expentries = new java.util.Vector();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      boolean exists = false;
      for (java.util.Enumeration enum = jj_expentries.elements(); enum.hasMoreElements();) {
        int[] oldentry = (int[])(enum.nextElement());
        if (oldentry.length == jj_expentry.length) {
          exists = true;
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              exists = false;
              break;
            }
          }
          if (exists) break;
        }
      }
      if (!exists) jj_expentries.addElement(jj_expentry);
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  final public ParseException generateParseException() {
    jj_expentries.removeAllElements();
    boolean[] la1tokens = new boolean[95];
    for (int i = 0; i < 95; i++) {
      la1tokens[i] = false;
    }
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 88; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
          if ((jj_la1_1[i] & (1<<j)) != 0) {
            la1tokens[32+j] = true;
          }
          if ((jj_la1_2[i] & (1<<j)) != 0) {
            la1tokens[64+j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 95; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.addElement(jj_expentry);
      }
    }
    jj_endpos = 0;
    jj_rescan_token();
    jj_add_error_token(0, 0);
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = (int[])jj_expentries.elementAt(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  final public void enable_tracing() {
  }

  final public void disable_tracing() {
  }

  final private void jj_rescan_token() {
    jj_rescan = true;
    for (int i = 0; i < 20; i++) {
      JJCalls p = jj_2_rtns[i];
      do {
        if (p.gen > jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
            case 1: jj_3_2(); break;
            case 2: jj_3_3(); break;
            case 3: jj_3_4(); break;
            case 4: jj_3_5(); break;
            case 5: jj_3_6(); break;
            case 6: jj_3_7(); break;
            case 7: jj_3_8(); break;
            case 8: jj_3_9(); break;
            case 9: jj_3_10(); break;
            case 10: jj_3_11(); break;
            case 11: jj_3_12(); break;
            case 12: jj_3_13(); break;
            case 13: jj_3_14(); break;
            case 14: jj_3_15(); break;
            case 15: jj_3_16(); break;
            case 16: jj_3_17(); break;
            case 17: jj_3_18(); break;
            case 18: jj_3_19(); break;
            case 19: jj_3_20(); break;
          }
        }
        p = p.next;
      } while (p != null);
    }
    jj_rescan = false;
  }

  final private void jj_save(int index, int xla) {
    JJCalls p = jj_2_rtns[index];
    while (p.gen > jj_gen) {
      if (p.next == null) { p = p.next = new JJCalls(); break; }
      p = p.next;
    }
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  }

  static final class JJCalls {
    int gen;
    Token first;
    int arg;
    JJCalls next;
  }

}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


Written By
Web Developer
Switzerland Switzerland
Patrik Reali was a senior software engineer for ELCA Informatique (www.elca.ch) in Zurich, Switzerland; in January 2005, he joined Google. He is specialized in systems and programming languages, with a strong interest for the .NET and Java platforms.

He got a PhD in computer science at ETH-Zurich working on the research operating system and language Oberon.

Together with Dominic Ullmann, he administers the open source project IIOP.NET.

Comments and Discussions