NodeTypes.java

package edu.udel.cis.vsl.tass.ast.parser;
import org.xml.sax.Attributes;
import java.util.HashMap;
import java.util.Map;
import java.io.PrintWriter;
import edu.udel.cis.vsl.tass.ast.IF.ASTNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.FileNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.GlobalScopeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.IdentifierNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.LabelNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.PairNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.ReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.RootNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.SequenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.SizeableNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.TypeDefinitionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.BoundVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.FormalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.FunctionDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.GlobalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.LocalVariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.declaration.VariableDeclarationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.AssignmentNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.BindingExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.ExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FunctionInvocationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.FunctionReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.IncrementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.IntegerLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.LHSExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.LiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.ModificationNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.OperatorNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.PureExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.RealLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.SideEffectExpressionNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.StringLiteralNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.SubscriptNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.expression.VariableReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.AssertStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.BlockNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ForLoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.IfThenElseStatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.LoopNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.PragmaNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.ReturnNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.statement.StatementNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.ArrayTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.BooleanTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.CompositeTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.IntegerTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.PointerTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.RealTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.TypeNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.TypeReferenceNodeIF;
import edu.udel.cis.vsl.tass.ast.IF.type.VoidTypeNodeIF;
import edu.udel.cis.vsl.tass.ast.impl.FileNode;
import edu.udel.cis.vsl.tass.ast.impl.IdentifierNode;
import edu.udel.cis.vsl.tass.ast.impl.LabelNode;
import edu.udel.cis.vsl.tass.ast.impl.PairNode;
import edu.udel.cis.vsl.tass.ast.impl.RootNode;
import edu.udel.cis.vsl.tass.ast.impl.SequenceNode;
import edu.udel.cis.vsl.tass.ast.impl.TypeDefinitionNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.BoundVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.FormalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.FunctionDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.GlobalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.LocalVariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.declaration.VariableDeclarationNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.AssignmentNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.BindingExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.ExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.FunctionInvocationNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.FunctionReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.IncrementNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.IntegerLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.LHSExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.LiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.ModificationNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.OperatorNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.PureExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.RealLiteralNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.SideEffectExpressionNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.SubscriptNode;
import edu.udel.cis.vsl.tass.ast.impl.expression.VariableReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.AssertStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.BlockNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ForLoopNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.IfThenElseStatementNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.PragmaNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.ReturnNode;
import edu.udel.cis.vsl.tass.ast.impl.statement.StatementNode;
import edu.udel.cis.vsl.tass.ast.impl.type.ArrayTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.BooleanTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.CompositeTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.IntegerTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.PointerTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.RealTypeNode;
import edu.udel.cis.vsl.tass.ast.impl.type.TypeReferenceNode;
import edu.udel.cis.vsl.tass.ast.impl.type.VoidTypeNode;
import edu.udel.cis.vsl.tass.number.IF.IntegerNumberIF;
import edu.udel.cis.vsl.tass.number.IF.RationalNumberIF;
import edu.udel.cis.vsl.tass.util.Source;
class NodeTypes
{
  private HashMap<String, NodeTypeIF> nodeTypeTbl;
  
  private RefMappers refMappers;
  
  public NodeTypes (RefMappers refMappers)
  {
    this.refMappers = refMappers;
    nodeTypeTbl = new HashMap<String, NodeTypeIF>();
    nodeTypeTbl.put("id_ArrayTypeNode", new ArrayTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_AssertStatementNode", new AssertStatementNode_type(this, refMappers));
    nodeTypeTbl.put("id_AssignmentNode", new AssignmentNode_type(this, refMappers));
    nodeTypeTbl.put("id_BindingExpressionNode", new BindingExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_BlockNode", new BlockNode_type(this, refMappers));
    nodeTypeTbl.put("id_BooleanTypeNode", new BooleanTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_BoundVariableDeclarationNode", new BoundVariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_CompositeTypeNode", new CompositeTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_ExpressionNode", new ExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_FileNode", new FileNode_type(this, refMappers));
    nodeTypeTbl.put("id_ForLoopNode", new ForLoopNode_type(this, refMappers));
    nodeTypeTbl.put("id_FormalVariableDeclarationNode", new FormalVariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_FunctionDeclarationNode", new FunctionDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_FunctionInvocationNode", new FunctionInvocationNode_type(this, refMappers));
    nodeTypeTbl.put("id_FunctionReferenceNode", new FunctionReferenceNode_type(this, refMappers));
    nodeTypeTbl.put("id_GlobalVariableDeclarationNode", new GlobalVariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_IdentifierNode", new IdentifierNode_type(this, refMappers));
    nodeTypeTbl.put("id_IfThenElseStatementNode", new IfThenElseStatementNode_type(this, refMappers));
    nodeTypeTbl.put("id_IncrementNode", new IncrementNode_type(this, refMappers));
    nodeTypeTbl.put("id_IntegerLiteralNode", new IntegerLiteralNode_type(this, refMappers));
    nodeTypeTbl.put("id_IntegerTypeNode", new IntegerTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_LHSExpressionNode", new LHSExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_LabelNode", new LabelNode_type(this, refMappers));
    nodeTypeTbl.put("id_LiteralNode", new LiteralNode_type(this, refMappers));
    nodeTypeTbl.put("id_LocalVariableDeclarationNode", new LocalVariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_ModificationNode", new ModificationNode_type(this, refMappers));
    nodeTypeTbl.put("id_OperatorNode", new OperatorNode_type(this, refMappers));
    nodeTypeTbl.put("id_PairNode_IdentifierNode_TypeNode", new PairNode_IdentifierNode_TypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_PointerTypeNode", new PointerTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_PragmaNode", new PragmaNode_type(this, refMappers));
    nodeTypeTbl.put("id_PureExpressionNode", new PureExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_RealLiteralNode", new RealLiteralNode_type(this, refMappers));
    nodeTypeTbl.put("id_RealTypeNode", new RealTypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_ReturnNode", new ReturnNode_type(this, refMappers));
    nodeTypeTbl.put("id_RootNode", new RootNode_type(this, refMappers));
    nodeTypeTbl.put("id_ExpressionNodes", new SequenceNode_ExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_FileNodes", new SequenceNode_FileNode_type(this, refMappers));
    nodeTypeTbl.put("id_FormalVariableDeclarationNodes", new SequenceNode_FormalVariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_GlobalScopeNodes", new SequenceNode_GlobalScopeNode_type(this, refMappers));
    nodeTypeTbl.put("id_LabelNodes", new SequenceNode_LabelNode_type(this, refMappers));
    nodeTypeTbl.put("id_PureExpressionNodes", new SequenceNode_PureExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_StatementNodes", new SequenceNode_StatementNode_type(this, refMappers));
    nodeTypeTbl.put("id_VariableDeclarationNodes", new SequenceNode_VariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_PairNode_IdentifierNode_TypeNodes", new SequenceNode_PairNode_IdentifierNode_TypeNode_type(this, refMappers));
    nodeTypeTbl.put("id_SideEffectExpressionNode", new SideEffectExpressionNode_type(this, refMappers));
    nodeTypeTbl.put("id_StatementNode", new StatementNode_type(this, refMappers));
    nodeTypeTbl.put("id_SubscriptNode", new SubscriptNode_type(this, refMappers));
    nodeTypeTbl.put("id_TypeDefinitionNode", new TypeDefinitionNode_type(this, refMappers));
    nodeTypeTbl.put("id_TypeReferenceNode", new TypeReferenceNode_type(this, refMappers));
    nodeTypeTbl.put("id_VariableDeclarationNode", new VariableDeclarationNode_type(this, refMappers));
    nodeTypeTbl.put("id_VariableReferenceNode", new VariableReferenceNode_type(this, refMappers));
    nodeTypeTbl.put("id_VoidTypeNode", new VoidTypeNode_type(this, refMappers));
  }
  
  public NodeTypeIF getNodeType (String id)
  {
    return nodeTypeTbl.get(id.trim());
  }
  
  public class ArrayTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public ArrayTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("elementType", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("extent", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public ArrayTypeNode_wrapper getEmptyNode (long id)
    {
      return new ArrayTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class AssertStatementNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public AssertStatementNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("predicate", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public AssertStatementNode_wrapper getEmptyNode (long id)
    {
      return new AssertStatementNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class AssignmentNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public AssignmentNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("assignmentType", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("lhs", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("rhs", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("assignmentType", new LeafAssignmentTypeParser(parent, refMappers));
    }
    
    public AssignmentNode_wrapper getEmptyNode (long id)
    {
      return new AssignmentNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class BindingExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public BindingExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("quantifier", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("boundVariable", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("constraint", new DescendentType(false, 0, 2, false, false));
      descendentTbl.put("expression", new DescendentType(false, 0, 3, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("quantifier", new LeafQuantifierParser(parent, refMappers));
    }
    
    public BindingExpressionNode_wrapper getEmptyNode (long id)
    {
      return new BindingExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class BlockNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public BlockNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("variables", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("statements", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public BlockNode_wrapper getEmptyNode (long id)
    {
      return new BlockNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class BooleanTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public BooleanTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public BooleanTypeNode_wrapper getEmptyNode (long id)
    {
      return new BooleanTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class BoundVariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public BoundVariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isConst", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isVolatile", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("isRestrict", new DescendentType(false, 0, 3, true, false));
      descendentTbl.put("storageClass", new DescendentType(false, 0, 4, true, false));
      descendentTbl.put("ben_containingExpression", new DescendentType(false, 0, 5, true, true));
      descendentTbl.put("type", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isConst", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isVolatile", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isRestrict", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("storageClass", new LeafStorageClassParser(parent, refMappers));
      leafParserTbl.put("ben_containingExpression", new LeafIntParser(parent, refMappers));
    }
    
    public BoundVariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new BoundVariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class CompositeTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public CompositeTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isUnion", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("fields", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("name", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isUnion", new LeafBoolParser(parent, refMappers));
    }
    
    public CompositeTypeNode_wrapper getEmptyNode (long id)
    {
      return new CompositeTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class ExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public ExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public ExpressionNode_wrapper getEmptyNode (long id)
    {
      return new ExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class FileNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public FileNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("fileName", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("contents", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isSystem", new DescendentType(false, 0, 2, true, false));
      leafParserTbl.put("fileName", new LeafStringParser(parent, refMappers));
      leafParserTbl.put("contents", new LeafStringParser(parent, refMappers));
      leafParserTbl.put("isSystem", new LeafBoolParser(parent, refMappers));
    }
    
    public FileNode_wrapper getEmptyNode (long id)
    {
      return new FileNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class ForLoopNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public ForLoopNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("body", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("invariants", new DescendentType(false, 0, 2, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 3, false, false));
      descendentTbl.put("condition", new DescendentType(false, 0, 4, false, false));
      descendentTbl.put("incrementer", new DescendentType(false, 0, 5, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public ForLoopNode_wrapper getEmptyNode (long id)
    {
      return new ForLoopNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class FormalVariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public FormalVariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isConst", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isVolatile", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("isRestrict", new DescendentType(false, 0, 3, true, false));
      descendentTbl.put("storageClass", new DescendentType(false, 0, 4, true, false));
      descendentTbl.put("fdn_function", new DescendentType(false, 0, 5, true, true));
      descendentTbl.put("type", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isConst", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isVolatile", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isRestrict", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("storageClass", new LeafStorageClassParser(parent, refMappers));
      leafParserTbl.put("fdn_function", new LeafIntParser(parent, refMappers));
    }
    
    public FormalVariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new FormalVariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class FunctionDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public FunctionDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("fdn_definition", new DescendentType(false, 0, 1, true, true));
      descendentTbl.put("identifier", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("outputType", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("formals", new DescendentType(false, 0, 2, false, false));
      descendentTbl.put("body", new DescendentType(false, 0, 3, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("fdn_definition", new LeafIntParser(parent, refMappers));
    }
    
    public FunctionDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new FunctionDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class FunctionInvocationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public FunctionInvocationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("function", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("arguments", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public FunctionInvocationNode_wrapper getEmptyNode (long id)
    {
      return new FunctionInvocationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class FunctionReferenceNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public FunctionReferenceNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("name", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("fdn_referent", new DescendentType(false, 0, 2, true, true));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("name", new LeafStringParser(parent, refMappers));
      leafParserTbl.put("fdn_referent", new LeafIntParser(parent, refMappers));
    }
    
    public FunctionReferenceNode_wrapper getEmptyNode (long id)
    {
      return new FunctionReferenceNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class GlobalVariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public GlobalVariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isConst", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isVolatile", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("isRestrict", new DescendentType(false, 0, 3, true, false));
      descendentTbl.put("storageClass", new DescendentType(false, 0, 4, true, false));
      descendentTbl.put("vdn_definition", new DescendentType(false, 0, 5, true, true));
      descendentTbl.put("isDefinition", new DescendentType(false, 0, 6, true, false));
      descendentTbl.put("isInput", new DescendentType(false, 0, 7, true, false));
      descendentTbl.put("isOutput", new DescendentType(false, 0, 8, true, false));
      descendentTbl.put("isShared", new DescendentType(false, 0, 9, true, false));
      descendentTbl.put("type", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 2, false, false));
      descendentTbl.put("inputAssumption", new DescendentType(false, 0, 3, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isConst", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isVolatile", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isRestrict", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("storageClass", new LeafStorageClassParser(parent, refMappers));
      leafParserTbl.put("vdn_definition", new LeafIntParser(parent, refMappers));
      leafParserTbl.put("isDefinition", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isInput", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isOutput", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isShared", new LeafBoolParser(parent, refMappers));
    }
    
    public GlobalVariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new GlobalVariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class IdentifierNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public IdentifierNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("name", new DescendentType(false, 0, 1, true, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("name", new LeafStringParser(parent, refMappers));
    }
    
    public IdentifierNode_wrapper getEmptyNode (long id)
    {
      return new IdentifierNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class IfThenElseStatementNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public IfThenElseStatementNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("condition", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("trueBranch", new DescendentType(false, 0, 2, false, false));
      descendentTbl.put("falseBranch", new DescendentType(false, 0, 3, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public IfThenElseStatementNode_wrapper getEmptyNode (long id)
    {
      return new IfThenElseStatementNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class IncrementNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public IncrementNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("prefix", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("increment", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("lhs", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("prefix", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("increment", new LeafBoolParser(parent, refMappers));
    }
    
    public IncrementNode_wrapper getEmptyNode (long id)
    {
      return new IncrementNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class IntegerLiteralNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public IntegerLiteralNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("integerValue", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("type", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("integerValue", new LeafTASSIntParser(parent, refMappers));
    }
    
    public IntegerLiteralNode_wrapper getEmptyNode (long id)
    {
      return new IntegerLiteralNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class IntegerTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public IntegerTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("intType", new DescendentType(false, 0, 1, true, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("intType", new LeafIntTypeParser(parent, refMappers));
    }
    
    public IntegerTypeNode_wrapper getEmptyNode (long id)
    {
      return new IntegerTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class LHSExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public LHSExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public LHSExpressionNode_wrapper getEmptyNode (long id)
    {
      return new LHSExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class LabelNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public LabelNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("stn_statement", new DescendentType(false, 0, 1, true, true));
      descendentTbl.put("identifier", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("stn_statement", new LeafIntParser(parent, refMappers));
    }
    
    public LabelNode_wrapper getEmptyNode (long id)
    {
      return new LabelNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class LiteralNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public LiteralNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("type", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public LiteralNode_wrapper getEmptyNode (long id)
    {
      return new LiteralNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class LocalVariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public LocalVariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isConst", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isVolatile", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("isRestrict", new DescendentType(false, 0, 3, true, false));
      descendentTbl.put("storageClass", new DescendentType(false, 0, 4, true, false));
      descendentTbl.put("bn_block", new DescendentType(false, 0, 5, true, true));
      descendentTbl.put("type", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isConst", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isVolatile", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isRestrict", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("storageClass", new LeafStorageClassParser(parent, refMappers));
      leafParserTbl.put("bn_block", new LeafIntParser(parent, refMappers));
    }
    
    public LocalVariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new LocalVariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class ModificationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public ModificationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("lhs", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public ModificationNode_wrapper getEmptyNode (long id)
    {
      return new ModificationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class OperatorNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public OperatorNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("operator", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("argument", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("operator", new LeafOperatorParser(parent, refMappers));
    }
    
    public OperatorNode_wrapper getEmptyNode (long id)
    {
      return new OperatorNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class PairNode_IdentifierNode_TypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public PairNode_IdentifierNode_TypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("left", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("right", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public PairNode_IdentifierNode_TypeNode_wrapper getEmptyNode (long id)
    {
      return new PairNode_IdentifierNode_TypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class PointerTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public PointerTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("baseType", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public PointerTypeNode_wrapper getEmptyNode (long id)
    {
      return new PointerTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class PragmaNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public PragmaNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("string", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("string", new LeafStringLiteralParser(parent, refMappers));
    }
    
    public PragmaNode_wrapper getEmptyNode (long id)
    {
      return new PragmaNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class PureExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public PureExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public PureExpressionNode_wrapper getEmptyNode (long id)
    {
      return new PureExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class RealLiteralNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public RealLiteralNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("realValue", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("type", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("realValue", new LeafRationalParser(parent, refMappers));
    }
    
    public RealLiteralNode_wrapper getEmptyNode (long id)
    {
      return new RealLiteralNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class RealTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public RealTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("floatType", new DescendentType(false, 0, 1, true, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("floatType", new LeafFloatTypeParser(parent, refMappers));
    }
    
    public RealTypeNode_wrapper getEmptyNode (long id)
    {
      return new RealTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class ReturnNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public ReturnNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("expression", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public ReturnNode_wrapper getEmptyNode (long id)
    {
      return new ReturnNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class RootNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public RootNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("fdn_mainFunction", new DescendentType(false, 0, 1, true, true));
      descendentTbl.put("globalScopeNodes", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("files", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("fdn_mainFunction", new LeafIntParser(parent, refMappers));
    }
    
    public RootNode_wrapper getEmptyNode (long id)
    {
      return new RootNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_ExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_ExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_ExpressionNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_ExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_FileNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_FileNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_FileNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_FileNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_FormalVariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_FormalVariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_FormalVariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_FormalVariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_GlobalScopeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_GlobalScopeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_GlobalScopeNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_GlobalScopeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_LabelNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_LabelNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_LabelNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_LabelNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_PureExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_PureExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_PureExpressionNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_PureExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_StatementNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_StatementNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_StatementNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_StatementNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_VariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_VariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_VariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_VariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SequenceNode_PairNode_IdentifierNode_TypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SequenceNode_PairNode_IdentifierNode_TypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("child", new DescendentType(true, 1, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SequenceNode_PairNode_IdentifierNode_TypeNode_wrapper getEmptyNode (long id)
    {
      return new SequenceNode_PairNode_IdentifierNode_TypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SideEffectExpressionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SideEffectExpressionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SideEffectExpressionNode_wrapper getEmptyNode (long id)
    {
      return new SideEffectExpressionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class StatementNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public StatementNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public StatementNode_wrapper getEmptyNode (long id)
    {
      return new StatementNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class SubscriptNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public SubscriptNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("arrayExpression", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("indexExpression", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public SubscriptNode_wrapper getEmptyNode (long id)
    {
      return new SubscriptNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class TypeDefinitionNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public TypeDefinitionNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("type", new DescendentType(false, 0, 1, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public TypeDefinitionNode_wrapper getEmptyNode (long id)
    {
      return new TypeDefinitionNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class TypeReferenceNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public TypeReferenceNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("name", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("tdn_referent", new DescendentType(false, 0, 2, true, true));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("name", new LeafStringParser(parent, refMappers));
      leafParserTbl.put("tdn_referent", new LeafIntParser(parent, refMappers));
    }
    
    public TypeReferenceNode_wrapper getEmptyNode (long id)
    {
      return new TypeReferenceNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class VariableDeclarationNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public VariableDeclarationNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("isConst", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("isVolatile", new DescendentType(false, 0, 2, true, false));
      descendentTbl.put("isRestrict", new DescendentType(false, 0, 3, true, false));
      descendentTbl.put("storageClass", new DescendentType(false, 0, 4, true, false));
      descendentTbl.put("type", new DescendentType(false, 0, 0, false, false));
      descendentTbl.put("identifier", new DescendentType(false, 0, 1, false, false));
      descendentTbl.put("initializer", new DescendentType(false, 0, 2, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("isConst", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isVolatile", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("isRestrict", new LeafBoolParser(parent, refMappers));
      leafParserTbl.put("storageClass", new LeafStorageClassParser(parent, refMappers));
    }
    
    public VariableDeclarationNode_wrapper getEmptyNode (long id)
    {
      return new VariableDeclarationNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class VariableReferenceNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public VariableReferenceNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      descendentTbl.put("name", new DescendentType(false, 0, 1, true, false));
      descendentTbl.put("vdn_referent", new DescendentType(false, 0, 2, true, true));
      descendentTbl.put("labels", new DescendentType(false, 0, 0, false, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
      leafParserTbl.put("name", new LeafStringParser(parent, refMappers));
      leafParserTbl.put("vdn_referent", new LeafIntParser(parent, refMappers));
    }
    
    public VariableReferenceNode_wrapper getEmptyNode (long id)
    {
      return new VariableReferenceNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class VoidTypeNode_type implements NodeTypeIF
  {
    private HashMap<String, NodeParserIF> leafParserTbl = new HashMap<String, NodeParserIF>();
    
    private HashMap<String, DescendentType> descendentTbl = new HashMap<String, DescendentType>();
    
    private NodeTypes parent;
    
    public VoidTypeNode_type (NodeTypes parent, RefMappers refMappers)
    {
      this.parent = parent;
      descendentTbl.put("source", new DescendentType(false, 0, 0, true, false));
      leafParserTbl.put("source", new LeafSourceParser(parent, refMappers));
    }
    
    public VoidTypeNode_wrapper getEmptyNode (long id)
    {
      return new VoidTypeNode_wrapper(id);
    }
    
    public NodeParserIF makeDescendent (String name)
    {
      return leafParserTbl.containsKey(name.trim()) ? leafParserTbl.get(name.trim()).makeInstance() : new NodeParser(parent, refMappers);
    }
    
    public int getPosition (String name, int lastPos)
    {
      return descendentTbl.get(name.trim()).getPosition(lastPos);
    }
    
    public boolean isAttr (String name)
    {
      return descendentTbl.get(name.trim()).isAttr();
    }
    
    public boolean isRefAttr (String name)
    {
      return descendentTbl.get(name.trim()).isReference();
    }
  }
  
  public class ArrayTypeNode_wrapper implements NodeEltWrapperIF
  {
    private ArrayTypeNode node;
    
    public ArrayTypeNode_wrapper (long id)
    {
      node = new ArrayTypeNode(id);
    }
    
    public ArrayTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setElementType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setExtent((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ArrayTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ArrayTypeNode_wrapper");
      }
    }
  }
  
  public class AssertStatementNode_wrapper implements NodeEltWrapperIF
  {
    private AssertStatementNode node;
    
    public AssertStatementNode_wrapper (long id)
    {
      node = new AssertStatementNode(id);
    }
    
    public AssertStatementNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setPredicate((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in AssertStatementNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in AssertStatementNode_wrapper");
      }
    }
  }
  
  public class AssignmentNode_wrapper implements NodeEltWrapperIF
  {
    private AssignmentNode node;
    
    public AssignmentNode_wrapper (long id)
    {
      node = new AssignmentNode(id);
    }
    
    public AssignmentNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setLhs((LHSExpressionNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setRhs((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in AssignmentNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setAssignmentType((AssignmentNodeIF.AST_ASSIGNMENT_TYPE) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in AssignmentNode_wrapper");
      }
    }
  }
  
  public class BindingExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private BindingExpressionNode node;
    
    public BindingExpressionNode_wrapper (long id)
    {
      node = new BindingExpressionNode(id);
    }
    
    public BindingExpressionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setBoundVariable((BoundVariableDeclarationNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setConstraint((PureExpressionNodeIF) (elt.getNode()));
          break;
        case 3:
          node.setExpression((PureExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BindingExpressionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setQuantifier((BindingExpressionNodeIF.Quantifier) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BindingExpressionNode_wrapper");
      }
    }
  }
  
  public class BlockNode_wrapper implements NodeEltWrapperIF
  {
    private BlockNode node;
    
    public BlockNode_wrapper (long id)
    {
      node = new BlockNode(id);
    }
    
    public BlockNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setVariables((SequenceNodeIF<VariableDeclarationNodeIF>) (elt.getNode()));
          break;
        case 2:
          node.setStatements((SequenceNodeIF<StatementNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BlockNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BlockNode_wrapper");
      }
    }
  }
  
  public class BooleanTypeNode_wrapper implements NodeEltWrapperIF
  {
    private BooleanTypeNode node;
    
    public BooleanTypeNode_wrapper (long id)
    {
      node = new BooleanTypeNode(id);
    }
    
    public BooleanTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in BooleanTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BooleanTypeNode_wrapper");
      }
    }
  }
  
  public class BoundVariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private BoundVariableDeclarationNode node;
    
    public BoundVariableDeclarationNode_wrapper (long id)
    {
      node = new BoundVariableDeclarationNode(id);
    }
    
    public BoundVariableDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInitializer((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BoundVariableDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setConst((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setVolatile((Boolean) (elt.getNode()));
          break;
        case 3:
          node.setRestrict((Boolean) (elt.getNode()));
          break;
        case 4:
          node.setStorageClass((VariableDeclarationNodeIF.StorageClass) (elt.getNode()));
          break;
        case 5:
          node.setContainingExpression((BindingExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in BoundVariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class CompositeTypeNode_wrapper implements NodeEltWrapperIF
  {
    private CompositeTypeNode node;
    
    public CompositeTypeNode_wrapper (long id)
    {
      node = new CompositeTypeNode(id);
    }
    
    public CompositeTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setFields((SequenceNodeIF<PairNodeIF<IdentifierNodeIF,TypeNodeIF>>) (elt.getNode()));
          break;
        case 1:
          node.setName((IdentifierNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in CompositeTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setUnion((Boolean) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in CompositeTypeNode_wrapper");
      }
    }
  }
  
  public class ExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private ExpressionNode node;
    
    public ExpressionNode_wrapper (long id)
    {
      node = new ExpressionNode(id);
    }
    
    public ExpressionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ExpressionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ExpressionNode_wrapper");
      }
    }
  }
  
  public class FileNode_wrapper implements NodeEltWrapperIF
  {
    private FileNode node;
    
    public FileNode_wrapper (long id)
    {
      node = new FileNode(id);
    }
    
    public FileNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in FileNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setFileName((String) (elt.getNode()));
          break;
        case 1:
          node.setContents((String) (elt.getNode()));
          break;
        case 2:
          node.setIsSystem((Boolean) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FileNode_wrapper");
      }
    }
  }
  
  public class ForLoopNode_wrapper implements NodeEltWrapperIF
  {
    private ForLoopNode node;
    
    public ForLoopNode_wrapper (long id)
    {
      node = new ForLoopNode(id);
    }
    
    public ForLoopNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setBody((StatementNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInvariants((SequenceNodeIF<PureExpressionNodeIF>) (elt.getNode()));
          break;
        case 3:
          node.setInitializer((StatementNodeIF) (elt.getNode()));
          break;
        case 4:
          node.setCondition((ExpressionNodeIF) (elt.getNode()));
          break;
        case 5:
          node.setIncrementer((StatementNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ForLoopNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ForLoopNode_wrapper");
      }
    }
  }
  
  public class FormalVariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private FormalVariableDeclarationNode node;
    
    public FormalVariableDeclarationNode_wrapper (long id)
    {
      node = new FormalVariableDeclarationNode(id);
    }
    
    public FormalVariableDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInitializer((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FormalVariableDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setConst((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setVolatile((Boolean) (elt.getNode()));
          break;
        case 3:
          node.setRestrict((Boolean) (elt.getNode()));
          break;
        case 4:
          node.setStorageClass((VariableDeclarationNodeIF.StorageClass) (elt.getNode()));
          break;
        case 5:
          node.setFunction((FunctionDeclarationNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FormalVariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class FunctionDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private FunctionDeclarationNode node;
    
    public FunctionDeclarationNode_wrapper (long id)
    {
      node = new FunctionDeclarationNode(id);
    }
    
    public FunctionDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setOutputType((TypeNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setFormals((SequenceNodeIF<FormalVariableDeclarationNodeIF>) (elt.getNode()));
          break;
        case 3:
          node.setBody((BlockNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setDefinition((FunctionDeclarationNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionDeclarationNode_wrapper");
      }
    }
  }
  
  public class FunctionInvocationNode_wrapper implements NodeEltWrapperIF
  {
    private FunctionInvocationNode node;
    
    public FunctionInvocationNode_wrapper (long id)
    {
      node = new FunctionInvocationNode(id);
    }
    
    public FunctionInvocationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setFunction((ExpressionNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setArguments((SequenceNodeIF<ExpressionNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionInvocationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionInvocationNode_wrapper");
      }
    }
  }
  
  public class FunctionReferenceNode_wrapper implements NodeEltWrapperIF
  {
    private FunctionReferenceNode node;
    
    public FunctionReferenceNode_wrapper (long id)
    {
      node = new FunctionReferenceNode(id);
    }
    
    public FunctionReferenceNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionReferenceNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setName((String) (elt.getNode()));
          break;
        case 2:
          node.setReferent((FunctionDeclarationNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in FunctionReferenceNode_wrapper");
      }
    }
  }
  
  public class GlobalVariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private GlobalVariableDeclarationNode node;
    
    public GlobalVariableDeclarationNode_wrapper (long id)
    {
      node = new GlobalVariableDeclarationNode(id);
    }
    
    public GlobalVariableDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInitializer((ExpressionNodeIF) (elt.getNode()));
          break;
        case 3:
          node.setInputAssumption((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in GlobalVariableDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setConst((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setVolatile((Boolean) (elt.getNode()));
          break;
        case 3:
          node.setRestrict((Boolean) (elt.getNode()));
          break;
        case 4:
          node.setStorageClass((VariableDeclarationNodeIF.StorageClass) (elt.getNode()));
          break;
        case 5:
          node.setDefinition((VariableDeclarationNodeIF) (elt.getNode()));
          break;
        case 6:
          node.setIsDefinition((Boolean) (elt.getNode()));
          break;
        case 7:
          node.setIsInput((Boolean) (elt.getNode()));
          break;
        case 8:
          node.setIsOutput((Boolean) (elt.getNode()));
          break;
        case 9:
          node.setIsShared((Boolean) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in GlobalVariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class IdentifierNode_wrapper implements NodeEltWrapperIF
  {
    private IdentifierNode node;
    
    public IdentifierNode_wrapper (long id)
    {
      node = new IdentifierNode(id);
    }
    
    public IdentifierNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in IdentifierNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setName((String) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IdentifierNode_wrapper");
      }
    }
  }
  
  public class IfThenElseStatementNode_wrapper implements NodeEltWrapperIF
  {
    private IfThenElseStatementNode node;
    
    public IfThenElseStatementNode_wrapper (long id)
    {
      node = new IfThenElseStatementNode(id);
    }
    
    public IfThenElseStatementNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setCondition((ExpressionNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setTrueBranch((StatementNodeIF) (elt.getNode()));
          break;
        case 3:
          node.setFalseBranch((StatementNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IfThenElseStatementNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IfThenElseStatementNode_wrapper");
      }
    }
  }
  
  public class IncrementNode_wrapper implements NodeEltWrapperIF
  {
    private IncrementNode node;
    
    public IncrementNode_wrapper (long id)
    {
      node = new IncrementNode(id);
    }
    
    public IncrementNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setLhs((LHSExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IncrementNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setPrefix((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setIncrement((Boolean) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IncrementNode_wrapper");
      }
    }
  }
  
  public class IntegerLiteralNode_wrapper implements NodeEltWrapperIF
  {
    private IntegerLiteralNode node;
    
    public IntegerLiteralNode_wrapper (long id)
    {
      node = new IntegerLiteralNode(id);
    }
    
    public IntegerLiteralNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IntegerLiteralNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setIntegerValue((IntegerNumberIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IntegerLiteralNode_wrapper");
      }
    }
  }
  
  public class IntegerTypeNode_wrapper implements NodeEltWrapperIF
  {
    private IntegerTypeNode node;
    
    public IntegerTypeNode_wrapper (long id)
    {
      node = new IntegerTypeNode(id);
    }
    
    public IntegerTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in IntegerTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setIntType((IntegerTypeNodeIF.IntType) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in IntegerTypeNode_wrapper");
      }
    }
  }
  
  public class LHSExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private LHSExpressionNode node;
    
    public LHSExpressionNode_wrapper (long id)
    {
      node = new LHSExpressionNode(id);
    }
    
    public LHSExpressionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LHSExpressionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LHSExpressionNode_wrapper");
      }
    }
  }
  
  public class LabelNode_wrapper implements NodeEltWrapperIF
  {
    private LabelNode node;
    
    public LabelNode_wrapper (long id)
    {
      node = new LabelNode(id);
    }
    
    public LabelNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LabelNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setStatement((StatementNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LabelNode_wrapper");
      }
    }
  }
  
  public class LiteralNode_wrapper implements NodeEltWrapperIF
  {
    private LiteralNode node;
    
    public LiteralNode_wrapper (long id)
    {
      node = new LiteralNode(id);
    }
    
    public LiteralNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LiteralNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LiteralNode_wrapper");
      }
    }
  }
  
  public class LocalVariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private LocalVariableDeclarationNode node;
    
    public LocalVariableDeclarationNode_wrapper (long id)
    {
      node = new LocalVariableDeclarationNode(id);
    }
    
    public LocalVariableDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInitializer((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LocalVariableDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setConst((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setVolatile((Boolean) (elt.getNode()));
          break;
        case 3:
          node.setRestrict((Boolean) (elt.getNode()));
          break;
        case 4:
          node.setStorageClass((VariableDeclarationNodeIF.StorageClass) (elt.getNode()));
          break;
        case 5:
          node.setBlock((BlockNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in LocalVariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class ModificationNode_wrapper implements NodeEltWrapperIF
  {
    private ModificationNode node;
    
    public ModificationNode_wrapper (long id)
    {
      node = new ModificationNode(id);
    }
    
    public ModificationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setLhs((LHSExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ModificationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ModificationNode_wrapper");
      }
    }
  }
  
  public class OperatorNode_wrapper implements NodeEltWrapperIF
  {
    private OperatorNode node;
    
    public OperatorNode_wrapper (long id)
    {
      node = new OperatorNode(id);
    }
    
    public OperatorNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
        case 2:
        case 3:
          node.setArgument(index - 1, (ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in OperatorNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setOperator((OperatorNodeIF.AST_OPERATOR) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in OperatorNode_wrapper");
      }
    }
  }
  
  public class PairNode_IdentifierNode_TypeNode_wrapper implements NodeEltWrapperIF
  {
    private PairNode<IdentifierNodeIF,TypeNodeIF> node;
    
    public PairNode_IdentifierNode_TypeNode_wrapper (long id)
    {
      node = new PairNode<IdentifierNodeIF,TypeNodeIF>(id);
    }
    
    public PairNode<IdentifierNodeIF,TypeNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLeft((IdentifierNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setRight((TypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PairNode_IdentifierNode_TypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PairNode_IdentifierNode_TypeNode_wrapper");
      }
    }
  }
  
  public class PointerTypeNode_wrapper implements NodeEltWrapperIF
  {
    private PointerTypeNode node;
    
    public PointerTypeNode_wrapper (long id)
    {
      node = new PointerTypeNode(id);
    }
    
    public PointerTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setBaseType((TypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PointerTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PointerTypeNode_wrapper");
      }
    }
  }
  
  public class PragmaNode_wrapper implements NodeEltWrapperIF
  {
    private PragmaNode node;
    
    public PragmaNode_wrapper (long id)
    {
      node = new PragmaNode(id);
    }
    
    public PragmaNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PragmaNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setString((StringLiteralNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PragmaNode_wrapper");
      }
    }
  }
  
  public class PureExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private PureExpressionNode node;
    
    public PureExpressionNode_wrapper (long id)
    {
      node = new PureExpressionNode(id);
    }
    
    public PureExpressionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PureExpressionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in PureExpressionNode_wrapper");
      }
    }
  }
  
  public class RealLiteralNode_wrapper implements NodeEltWrapperIF
  {
    private RealLiteralNode node;
    
    public RealLiteralNode_wrapper (long id)
    {
      node = new RealLiteralNode(id);
    }
    
    public RealLiteralNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setType((RealTypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in RealLiteralNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setRealValue((RationalNumberIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in RealLiteralNode_wrapper");
      }
    }
  }
  
  public class RealTypeNode_wrapper implements NodeEltWrapperIF
  {
    private RealTypeNode node;
    
    public RealTypeNode_wrapper (long id)
    {
      node = new RealTypeNode(id);
    }
    
    public RealTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in RealTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setFloatType((RealTypeNodeIF.FloatType) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in RealTypeNode_wrapper");
      }
    }
  }
  
  public class ReturnNode_wrapper implements NodeEltWrapperIF
  {
    private ReturnNode node;
    
    public ReturnNode_wrapper (long id)
    {
      node = new ReturnNode(id);
    }
    
    public ReturnNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setExpression((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ReturnNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in ReturnNode_wrapper");
      }
    }
  }
  
  public class RootNode_wrapper implements NodeEltWrapperIF
  {
    private RootNode node;
    
    public RootNode_wrapper (long id)
    {
      node = new RootNode(id);
    }
    
    public RootNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setGlobalScopeNodes((SequenceNodeIF<GlobalScopeNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setFiles((SequenceNodeIF<FileNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in RootNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setMainFunction((FunctionDeclarationNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in RootNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_ExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<ExpressionNodeIF> node;
    
    public SequenceNode_ExpressionNode_wrapper (long id)
    {
      node = new SequenceNode<ExpressionNodeIF>(id);
    }
    
    public SequenceNode<ExpressionNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (ExpressionNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_ExpressionNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_FileNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<FileNodeIF> node;
    
    public SequenceNode_FileNode_wrapper (long id)
    {
      node = new SequenceNode<FileNodeIF>(id);
    }
    
    public SequenceNode<FileNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (FileNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_FileNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_FormalVariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<FormalVariableDeclarationNodeIF> node;
    
    public SequenceNode_FormalVariableDeclarationNode_wrapper (long id)
    {
      node = new SequenceNode<FormalVariableDeclarationNodeIF>(id);
    }
    
    public SequenceNode<FormalVariableDeclarationNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (FormalVariableDeclarationNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_FormalVariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_GlobalScopeNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<GlobalScopeNodeIF> node;
    
    public SequenceNode_GlobalScopeNode_wrapper (long id)
    {
      node = new SequenceNode<GlobalScopeNodeIF>(id);
    }
    
    public SequenceNode<GlobalScopeNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (GlobalScopeNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_GlobalScopeNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_LabelNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<LabelNodeIF> node;
    
    public SequenceNode_LabelNode_wrapper (long id)
    {
      node = new SequenceNode<LabelNodeIF>(id);
    }
    
    public SequenceNode<LabelNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (LabelNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_LabelNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_PureExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<PureExpressionNodeIF> node;
    
    public SequenceNode_PureExpressionNode_wrapper (long id)
    {
      node = new SequenceNode<PureExpressionNodeIF>(id);
    }
    
    public SequenceNode<PureExpressionNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (PureExpressionNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_PureExpressionNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_StatementNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<StatementNodeIF> node;
    
    public SequenceNode_StatementNode_wrapper (long id)
    {
      node = new SequenceNode<StatementNodeIF>(id);
    }
    
    public SequenceNode<StatementNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (StatementNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_StatementNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_VariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<VariableDeclarationNodeIF> node;
    
    public SequenceNode_VariableDeclarationNode_wrapper (long id)
    {
      node = new SequenceNode<VariableDeclarationNodeIF>(id);
    }
    
    public SequenceNode<VariableDeclarationNodeIF> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (VariableDeclarationNodeIF) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_VariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class SequenceNode_PairNode_IdentifierNode_TypeNode_wrapper implements NodeEltWrapperIF
  {
    private SequenceNode<PairNodeIF<IdentifierNodeIF,TypeNodeIF>> node;
    
    public SequenceNode_PairNode_IdentifierNode_TypeNode_wrapper (long id)
    {
      node = new SequenceNode<PairNodeIF<IdentifierNodeIF,TypeNodeIF>>(id);
    }
    
    public SequenceNode<PairNodeIF<IdentifierNodeIF,TypeNodeIF>> getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          switch ((index - 0) % 1)
          {
            case 0:
              node.setChild((index - 0) / 1, (PairNodeIF<IdentifierNodeIF,TypeNodeIF>) (elt.getNode()));
              break;
          }
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SequenceNode_PairNode_IdentifierNode_TypeNode_wrapper");
      }
    }
  }
  
  public class SideEffectExpressionNode_wrapper implements NodeEltWrapperIF
  {
    private SideEffectExpressionNode node;
    
    public SideEffectExpressionNode_wrapper (long id)
    {
      node = new SideEffectExpressionNode(id);
    }
    
    public SideEffectExpressionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SideEffectExpressionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SideEffectExpressionNode_wrapper");
      }
    }
  }
  
  public class StatementNode_wrapper implements NodeEltWrapperIF
  {
    private StatementNode node;
    
    public StatementNode_wrapper (long id)
    {
      node = new StatementNode(id);
    }
    
    public StatementNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in StatementNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in StatementNode_wrapper");
      }
    }
  }
  
  public class SubscriptNode_wrapper implements NodeEltWrapperIF
  {
    private SubscriptNode node;
    
    public SubscriptNode_wrapper (long id)
    {
      node = new SubscriptNode(id);
    }
    
    public SubscriptNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        case 1:
          node.setArrayExpression((ExpressionNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setIndexExpression((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SubscriptNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in SubscriptNode_wrapper");
      }
    }
  }
  
  public class TypeDefinitionNode_wrapper implements NodeEltWrapperIF
  {
    private TypeDefinitionNode node;
    
    public TypeDefinitionNode_wrapper (long id)
    {
      node = new TypeDefinitionNode(id);
    }
    
    public TypeDefinitionNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in TypeDefinitionNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in TypeDefinitionNode_wrapper");
      }
    }
  }
  
  public class TypeReferenceNode_wrapper implements NodeEltWrapperIF
  {
    private TypeReferenceNode node;
    
    public TypeReferenceNode_wrapper (long id)
    {
      node = new TypeReferenceNode(id);
    }
    
    public TypeReferenceNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in TypeReferenceNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setName((String) (elt.getNode()));
          break;
        case 2:
          node.setReferent((TypeDefinitionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in TypeReferenceNode_wrapper");
      }
    }
  }
  
  public class VariableDeclarationNode_wrapper implements NodeEltWrapperIF
  {
    private VariableDeclarationNode node;
    
    public VariableDeclarationNode_wrapper (long id)
    {
      node = new VariableDeclarationNode(id);
    }
    
    public VariableDeclarationNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setType((TypeNodeIF) (elt.getNode()));
          break;
        case 1:
          node.setIdentifier((IdentifierNodeIF) (elt.getNode()));
          break;
        case 2:
          node.setInitializer((ExpressionNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in VariableDeclarationNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setConst((Boolean) (elt.getNode()));
          break;
        case 2:
          node.setVolatile((Boolean) (elt.getNode()));
          break;
        case 3:
          node.setRestrict((Boolean) (elt.getNode()));
          break;
        case 4:
          node.setStorageClass((VariableDeclarationNodeIF.StorageClass) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in VariableDeclarationNode_wrapper");
      }
    }
  }
  
  public class VariableReferenceNode_wrapper implements NodeEltWrapperIF
  {
    private VariableReferenceNode node;
    
    public VariableReferenceNode_wrapper (long id)
    {
      node = new VariableReferenceNode(id);
    }
    
    public VariableReferenceNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setLabels((SequenceNodeIF<LabelNodeIF>) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in VariableReferenceNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        case 1:
          node.setName((String) (elt.getNode()));
          break;
        case 2:
          node.setReferent((VariableDeclarationNodeIF) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in VariableReferenceNode_wrapper");
      }
    }
  }
  
  public class VoidTypeNode_wrapper implements NodeEltWrapperIF
  {
    private VoidTypeNode node;
    
    public VoidTypeNode_wrapper (long id)
    {
      node = new VoidTypeNode(id);
    }
    
    public VoidTypeNode getNode ()
    {
      return node;
    }
    
    public void setChild (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        default:
          throw new ParserException("Could not set element in VoidTypeNode_wrapper");
      }
    }
    
    public void setAttr (int index, NodeEltWrapperIF elt)
    {
      switch (index)
      {
        case 0:
          node.setSource((Source) (elt.getNode()));
          break;
        default:
          throw new ParserException("Could not set element in VoidTypeNode_wrapper");
      }
    }
  }
}