{

    /** Overall symbol table for translator */

    public static SymbolTable symbolTable = new SymbolTable();

    // This method decides what action to take based on the type of

    //   file we are looking at

    public  static void doFile(File f) throws Exception {

      // If this is a directory, walk each file/dir in that directory

      translateFilePath = f.getParent();

      if (f.isDirectory()) {

        String files[] = f.list();

        for(int i=0; i < files.length; i++)

        {

          doFile(new File(f, files[i]));

        }

      }

      // otherwise, if this is a Pascal file, parse it!

      else if ((f.getName().length()>4) &&

             f.getName().substring(f.getName().length()-4).toLowerCase().equals(".pas")) {

        System.err.println("   "+f.getAbsolutePath());

        if (translateFileName == null) {

          translateFileName = f.getName(); //set this file as the one to translate

          currentFileName = f.getName();

        }

        parseFile(f.getName(),new FileInputStream(f));

      }

      else {

        System.err.println("Can not parse:   "+f.getAbsolutePath());

      }

    }

    // Here's where we do the real work...

    public  static void parseFile(String f,InputStream s) throws Exception {

      try {

        currentFileName = f; // set this File as the currentFileName

        // Create a scanner that reads from the input stream passed to us

         PascalLexer lexer = new PascalLexer(s);

        // Create a parser that reads from the scanner

         PascalParser parser = new PascalParser(lexer);

        // set AST type to PascalAST (has symbol)

        parser.setASTNodeClass("PascalAST");

        // start parsing at the program rule

        parser.program();

        CommonAST t = (CommonAST)parser.getAST();

        // do something with the tree

        parser.doTreeAction(f, parser.getAST(), parser.getTokenNames());

        //System.out.println(parser.getAST().toStringList());

           

// build symbol table

       

        // Get the tree out of the parser

        AST resultTree1 = parser.getAST();

        // Make an instance of the tree parser

        // PascalTreeParserSuper treeParser1 = new PascalTreeParserSuper();

        SymtabPhase treeParser1 = new SymtabPhase();

        treeParser1.setASTNodeClass("PascalAST");

        // Begin tree parser at only rule

        treeParser1.program(resultTree1);

      

      }

      catch (Exception e) {

        System.err.println("parser exception: "+e);

        e.printStackTrace();   // so we can get stack trace

      }

    }

    public void doTreeAction(String f, AST t, String[] tokenNames) {

      if ( t==null ) return;

      if ( showTree ) {

         ((CommonAST)t).setVerboseStringConversion(true, tokenNames);

         ASTFactory factory = new ASTFactory();

         AST r = factory.create(0,"AST ROOT");

         r.setFirstChild(t);

         ASTFrame frame = new ASTFrame("Pascal AST", r);

         frame.setVisible(true);

         //System.out.println(t.toStringList());

      }

    }

  static boolean showTree = true;

  public static String translateFilePath;

  public static String translateFileName;

  public static String currentFileName; // not static, recursive USES ... other FileName in currentFileName

  public static String oldtranslateFileName;

  public static void main(String[] args) {

    // Use a try/catch block for parser exceptions

    try {

      // if we have at least one command-line argument

      if (args.length > 0 ) {

        // for each directory/file specified on the command line

        for(int i=0; i< args.length;i++)

{

    if ( args[i].equals("-showtree") ) {

             showTree = true;

          }

          else {

            System.err.println("Parsing...");

            doFile(new File(args[i])); // parse it

          }

        }

      }

      else

        System.err.println("Usage: java PascalParser <file/directory name>");

    }

    catch(Exception e) {

      System.err.println("exception: "+e);

      e.printStackTrace(System.err);   // so we can get stack trace

    }

  }

  super(tokenBuf,k);

  tokenNames = _tokenNames;

  buildTokenTypeASTClassMap();

  astFactory = new ASTFactory(getTokenTypeToASTClassMap());

  this(tokenBuf,2);

  super(lexer,k);

  tokenNames = _tokenNames;

  buildTokenTypeASTClassMap();

  astFactory = new ASTFactory(getTokenTypeToASTClassMap());

  this(lexer,2);

  super(state,2);

  tokenNames = _tokenNames;

  buildTokenTypeASTClassMap();

  astFactory = new ASTFactory(getTokenTypeToASTClassMap());

  public final void program() throws RecognitionException, TokenStreamException {

   

    returnAST = null;

    ASTPair currentAST = new ASTPair();

    PascalAST program_AST = null;

   

    programHeading();

    astFactory.addASTChild(currentAST, returnAST);

    {

    switch ( LA(1)) {

    case INTERFACE:

    {

      match(INTERFACE);

      break;

    }

    case IMPLEMENTATION:

    case USES:

    case LABEL:

    case CONST:

    case TYPE:

    case FUNCTION:

    case PROCEDURE:

    case VAR:

    case BEGIN:

    {

      break;

    }

    default:

    {

      throw new NoViableAltException(LT(1), getFilename());

    }

    }

    }

    block();

    astFactory.addASTChild(currentAST, returnAST);

    match(DOT);

    program_AST = (PascalAST)currentAST.root;

    returnAST = program_AST;

  }

 

  public final void programHeading() throws RecognitionException, TokenStreamException {

   

    returnAST = null;

    ASTPair currentAST = new ASTPair();

    PascalAST programHeading_AST = null;

   

    switch ( LA(1)) {

    case PROGRAM:

    {

      PascalAST tmp3_AST = null;

      tmp3_AST = (PascalAST)astFactory.create(LT(1));

      astFactory.makeASTRoot(currentAST, tmp3_AST);

      match(PROGRAM);

      identifier();

      astFactory.addASTChild(currentAST, returnAST);

      match(LPAREN);

      identifierList();

      astFactory.addASTChild(currentAST, returnAST);

      match(RPAREN);

      match(SEMI);

      programHeading_AST = (PascalAST)currentAST.root;

      break;

    }

    case UNIT:

    {

      PascalAST tmp7_AST = null;

      tmp7_AST = (PascalAST)astFactory.create(LT(1));

      astFactory.makeASTRoot(currentAST, tmp7_AST);

      match(UNIT);

      identifier();

      astFactory.addASTChild(currentAST, returnAST);

      match(SEMI);

      programHeading_AST = (PascalAST)currentAST.root;

      break;

    }

    default:

    {

      throw new NoViableAltException(LT(1), getFilename());

    }

    }

    returnAST = programHeading_AST;

  }

 

  public final void block() throws RecognitionException, TokenStreamException {

   

    returnAST = null;

    ASTPair currentAST = new ASTPair();

    PascalAST block_AST = null;

   

    {

    _loop7:

    do {

      switch ( LA(1)) {

      case LABEL:

      {

        labelDeclarationPart();

        astFactory.addASTChild(currentAST, returnAST);

        break;

      }

      case CONST:

      {

        constantDefinitionPart();

        astFactory.addASTChild(currentAST, returnAST);

        break;

      }

      case TYPE:

      {

        typeDefinitionPart();

        astFactory.addASTChild(currentAST, returnAST);

        break;

      }

      case VAR: