exprlexer.java~

实现的一个简单的语言编译器,可以编译类JAVA 的小语言

            // store back cached positions
            zzCurrentPos  = zzCurrentPosL;
            zzMarkedPos   = zzMarkedPosL;
            boolean eof = zzRefill();
            // get translated positions and possibly new buffer
            zzCurrentPosL  = zzCurrentPos;
            zzMarkedPosL   = zzMarkedPos;
            zzBufferL      = zzBuffer;
            zzEndReadL     = zzEndRead;
            if (eof) {
              zzInput = YYEOF;
              break zzForAction;
            }
            else {
              zzInput = zzBufferL[zzCurrentPosL++];
            }
          }
          int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
          if (zzNext == -1) break zzForAction;
          zzState = zzNext;

          int zzAttributes = zzAttrL[zzState];
          if ( (zzAttributes & 1) == 1 ) {
            zzAction = zzState;
            zzMarkedPosL = zzCurrentPosL;
            if ( (zzAttributes & 8) == 8 ) break zzForAction;
          }

        }
      }

      // store back cached position
      zzMarkedPos = zzMarkedPosL;

      switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
        case 2: 
          { /* ignore */
          }
        case 66: break;
        case 62: 
          { return symbol(ExprSymbol.KString);
          }
        case 67: break;
        case 42: 
          { string.append( '\f' );
          }
        case 68: break;
        case 60: 
          { return symbol(ExprSymbol.RETURN);
          }
        case 69: break;
        case 54: 
          { return symbol(ExprSymbol.FINAL);
          }
        case 70: break;
        case 43: 
          { string.append( '\b' );
          }
        case 71: break;
        case 28: 
          { return symbol(ExprSymbol.MUL_EQ);
          }
        case 72: break;
        case 29: 
          { return symbol(ExprSymbol.INTEGER_LITERAL, new Integer((int) parseLong(0, yylength(), 8)));
          }
        case 73: break;
        case 50: 
          { return symbol(ExprSymbol.INT);
          }
        case 74: break;
        case 12: 
          { return symbol(ExprSymbol.LBRACK);
          }
        case 75: break;
        case 61: 
          { return symbol(ExprSymbol.STATIC);
          }
        case 76: break;
        case 46: 
          { string.append( '\t' );
          }
        case 77: break;
        case 39: 
          { return symbol(ExprSymbol.AND);
          }
        case 78: break;
        case 20: 
          { return symbol(ExprSymbol.NOT);
          }
        case 79: break;
        case 3: 
          { return symbol(ExprSymbol.DIV);
          }
        case 80: break;
        case 7: 
          { return symbol(ExprSymbol.LPAREN);
          }
        case 81: break;
        case 48: 
          { string.append( '\'' );
          }
        case 82: break;
        case 21: 
          { return symbol(ExprSymbol.GREAT);
          }
        case 83: break;
        case 56: 
          { return symbol(ExprSymbol.WHILE);
          }
        case 84: break;
        case 35: 
          { return symbol(ExprSymbol.NOT_EQ);
          }
        case 85: break;
        case 65: 
          { return symbol(ExprSymbol.CONTINUE);
          }
        case 86: break;
        case 57: 
          { return symbol(ExprSymbol.BREAK);
          }
        case 87: break;
        case 11: 
          { return symbol(ExprSymbol.RBRACE);
          }
        case 88: break;
        case 25: 
          { throw new RuntimeException("Unterminated string at end of line");
          }
        case 89: break;
        case 49: 
          { return symbol(ExprSymbol.INTEGER_LITERAL, new Integer((int) parseLong(2, yylength(), 16)));
          }
        case 90: break;
        case 33: 
          { return symbol(ExprSymbol.MINUS_EQ);
          }
        case 91: break;
        case 63: 
          { return symbol(ExprSymbol.BOOLEAN);
          }
        case 92: break;
        case 18: 
          { return symbol(ExprSymbol.MINUS);
          }
        case 93: break;
        case 27: 
          { return symbol(ExprSymbol.DIV_EQ);
          }
        case 94: break;
        case 34: 
          { return symbol(ExprSymbol.REMAINDER_EQ);
          }
        case 95: break;
        case 55: 
          { return symbol(ExprSymbol.KFALSE);
          }
        case 96: break;
        case 5: 
          { return symbol(ExprSymbol.IDENTIFIER, yytext());
          }
        case 97: break;
        case 64: 
          { return symbol(ExprSymbol.PROGRAM);
          }
        case 98: break;
        case 32: 
          { return symbol(ExprSymbol.EQ_EQ);
          }
        case 99: break;
        case 47: 
          { string.append( '\"' );
          }
        case 100: break;
        case 13: 
          { return symbol(ExprSymbol.RBRACK);
          }
        case 101: break;
        case 14: 
          { return symbol(ExprSymbol.COMMA);
          }
        case 102: break;
        case 9: 
          { return symbol(ExprSymbol.SEMICOLON);
          }
        case 103: break;
        case 30: 
          { return symbol(ExprSymbol.IF);
          }
        case 104: break;
        case 19: 
          { return symbol(ExprSymbol.REMAINDER);
          }
        case 105: break;
        case 16: 
          { return symbol(ExprSymbol.PLUS);
          }
        case 106: break;
        case 52: 
          { return symbol(ExprSymbol.KTRUE);
          }
        case 107: break;
        case 37: 
          { return symbol(ExprSymbol.LESS_EQ);
          }
        case 108: break;
        case 22: 
          { return symbol(ExprSymbol.LESS);
          }
        case 109: break;
        case 36: 
          { return symbol(ExprSymbol.GREAT_EQ);
          }
        case 110: break;
        case 6: 
          { return symbol(ExprSymbol.INTEGER_LITERAL, new Integer(yytext()));
          }
        case 111: break;
        case 8: 
          { return symbol(ExprSymbol.RPAREN);
          }
        case 112: break;
        case 44: 
          { string.append( '\r' );
          }
        case 113: break;
        case 38: 
          { return symbol(ExprSymbol.OR);
          }
        case 114: break;
        case 17: 
          { return symbol(ExprSymbol.EQ);
          }
        case 115: break;
        case 58: 
          { return symbol(ExprSymbol.CLASS);
          }
        case 116: break;
        case 41: 
          { string.append( '\\' );
          }
        case 117: break;
        case 23: 
          { yybegin(STRING); string.setLength(0);
          }
        case 118: break;
        case 53: 
          { return symbol(ExprSymbol.VOID);
          }
        case 119: break;
        case 59: 
          { return symbol(ExprSymbol.LENGTH);
          }
        case 120: break;
        case 51: 
          { return symbol(ExprSymbol.ELSE);
          }
        case 121: break;
        case 1: 
          { throw new RuntimeException("Illegal character \""+yytext()+
                                                              "\" at line "+yyline+", column "+yycolumn);
          }
        case 122: break;
        case 45: 
          { string.append( '\n' );
          }
        case 123: break;
        case 10: 
          { return symbol(ExprSymbol.LBRACE);
          }
        case 124: break;
        case 4: 
          { return symbol(ExprSymbol.MULT);
          }
        case 125: break;
        case 24: 
          { string.append( yytext() );
          }
        case 126: break;
        case 15: 
          { return symbol(ExprSymbol.DOT);
          }
        case 127: break;
        case 40: 
          { throw new RuntimeException("Illegal escape sequence \""+yytext()+"\"");
          }
        case 128: break;
        case 26: 
          { yybegin(YYINITIAL); return symbol(ExprSymbol.STRING_LITERAL, string.toString());
          }
        case 129: break;
        case 31: 
          { return symbol(ExprSymbol.PLUS_EQ);
          }
        case 130: break;
        default: 
          if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
            zzAtEOF = true;
            zzDoEOF();
              {
                return symbol(ExprSymbol.EOF);
              }
          } 
          else {
            zzScanError(ZZ_NO_MATCH);
          }
      }
    }
  }

  /**
   * Converts an int token code into the name of the
   * token by reflection on the cup symbol class/interface ExprSymbol
   *
   * This code was contributed by Karl Meissner <[e-mail]>
   */
  private String getTokenName(int token) {
    try {
      java.lang.reflect.Field [] classFields = ExprSymbol.class.getFields();
      for (int i = 0; i < classFields.length; i++) {
        if (classFields[i].getInt(null) == token) {
          return classFields[i].getName();
        }
      }
    } catch (Exception e) {
      e.printStackTrace(System.err);
    }

    return "UNKNOWN TOKEN";
  }

  /**
   * Same as next_token but also prints the token to standard out
   * for debugging.
   *
   * This code was contributed by Karl Meissner <[e-mail]>
   */
  public java_cup.runtime.Symbol debug_next_token() throws java.io.IOException {
    java_cup.runtime.Symbol s = next_token();
    System.out.println( "line:" + (yyline+1) + " col:" + (yycolumn+1) + " --"+ yytext() + "--" + getTokenName(s.sym) + "--");
    return s;
  }

  /**
   * Runs the scanner on input files.
   *
   * This main method is the debugging routine for the scanner.
   * It prints debugging information about each returned token to
   * System.out until the end of file is reached, or an error occured.
   *
   * @param argv   the command line, contains the filenames to run
   *               the scanner on.
   */
  public static void main(String argv[]) {
    if (argv.length == 0) {
      System.out.println("Usage : java ExprLexer <inputfile>");
    }
    else {
      for (int i = 0; i < argv.length; i++) {
        ExprLexer scanner = null;
        try {
          scanner = new ExprLexer( new java.io.FileReader(argv[i]) );
          while ( !scanner.zzAtEOF ) scanner.debug_next_token();
        }
        catch (java.io.FileNotFoundException e) {
          System.out.println("File not found : \""+argv[i]+"\"");
        }
        catch (java.io.IOException e) {
          System.out.println("IO error scanning file \""+argv[i]+"\"");
          System.out.println(e);
        }
        catch (Exception e) {
          System.out.println("Unexpected exception:");
          e.printStackTrace();
        }
      }
    }
  }


}