javaCC学习笔记

javaCC的功能和yacc相似，主要根据bnf范式生成解析程序，不过javaCC是集合了词法分析和语法分析生成java解析代码，主页为：https://javacc.dev.java.net/

   javaCC有三个工具

javaCC  用来处理语法文件（jj）生成解析代码；

jjTree 用来处理jjt文件，生成树节点代码和jj文件，然后再通过javaCC生成解析代码；

jjDoc 根据jj文件生成bnf范式文档（html）

javaCC使用的各种语言的Grammar 文件这里有很多http://www.cobase.cs.ucla.edu/pub/javacc/ ，例如html,xml,python,vb…..,很多足够用了，呵呵。

javaCC 的使用

   javaCC生成的文件中，最主要的是《Grammar》.java这个就是解析器的主程序了了，《Grammar》名由jj中定义。

现在根据例子说明jj文件的定义：

BNF范式为：

/*这是一个整数的四则运算的例子*/

/* 运行 javaCC Grammar.jj

javac *.java

java  Grammar

>>> 1+1*(1+1)

3

>>>^Z

*/

PARSER_BEGIN(Grammar) /*解析代码的入口*/

public class Grammar  {

       public static final int PlusOP=1;

       public static final int MinusOP=2;

       public static final int TimersOP=3;

       public static final int OverOP=4;

  public static void main(String args[]) throws ParseException {

    Grammar parser = new Grammar(System.in);

    parser.Expression();

  }

}

PARSER_END(Grammar)

SKIP :  /* 不处理的字符*/

{

  " " | "\t" 

}

TOKEN : /*生成token的字符定义*/

{

  < ID: ["a"-"z","A"-"Z","_"] ( ["a"-"z","A"-"Z","_","0"-"9"] )* >

|  < NUM: ( ["0"-"9"] )+ >

|  < PLUS:   "+" >

|  < MINUS:  "-" >

|  < TIMERS: "*" >

|  < OVER:   "/" >

|  < LPAREN: "(" >

|  < RPAREN: ")" >

|  <NEWLINE: ("\r\n"|"\n"|"\r")>

}

void Expression() :

/*完成 Expression  ::=( ( <NEWLINE> )* Simple_Expression <NEWLINE> )* <EOF> 的配陪*/

{

         int value=0;  /* 这个｛｝中是Expression()的定义的局部变量*/

}

{                

       {

       System.out.print(">>>");

       }

 (  (<NEWLINE>  /* 首先匹配NEWLINE 这个taken，完成后转到下一个解析*/

     {

          System.out.print(">>>");  /*在<NEWLINE>下的｛｝中为如果匹配到<NEWLINE>执行的java代码。*/

     }

     )* value= Simple_Expression()  <NEWLINE>  /*在换行之前Simple_Expression()解析表达式 ，输入换行后，一个预算解析完成*/

   {System.out.println(value);

     System.out.print(">>>");/*在<NEWLINE>下的｛｝中为完成表达式解析，匹配到<NEWLINE>执行的java代码。*/

   }

 )*

 <EOF>      /*系统定义的taken,输入结束符*/

}

int Simple_Expression() :

/*完成Simple_Expression ::=bnf Term ( addop Term )*配陪 */

{

       /* 这个｛｝中是Simple_Expression()的定义的局部变量*/

          int value;

         int tValue;

         int op;

}

{

  value= Term (){}   /*配陪Term 相*/

  (

  op=addop() tValue=Term()

{

                  switch(op)

                   {

                            case PlusOP:

                           value=value+tValue;

                            break;

                            case MinusOP:

                            value=value - tValue;

                            break;

                   }

         }

  )*  /*匹配 ( addop Term )* */

  { return value; }

}

int addop() : {}

{

         <PLUS> { return PlusOP; }

|   <MINUS> { return MinusOP; }

}

int Term() :

{

         int value;

         int tValue;

         int op;

}

{

  value=Factor(){}

  (

  op=mulop() tValue=Factor()

{

                  switch(op)

                  {

                            case TimersOP:

                            value=value * tValue;

                            break;

                            case OverOP:

                            value=value / tValue;

                            break;

                   }

         }

  )*

  {

       return value;

  }

}

int mulop() :{}

{

         <TIMERS> { return TimersOP; }

         | <OVER> { return OverOP;   }

}

int Factor() :

{

       int value;

        Token t;

}

{

  t=<ID>    /*获得<ID>的解析的值*/

{

          value=100; 

          return value;

         }

  |

  t=<NUM>

  {

       value= (Integer.valueOf(t.image)).intValue();

       return value;

    }

|

  t=<MINUS>

  {

       value=0-Factor();

       return value;

    }    

  |

  t=<PLUS>

  {

       value=Factor();

       return value;

    }            

  |

  <LPAREN> value=Simple_Expression() <RPAREN>

  {

         return value;

  }

}

根据例子： 基本上是一个taken下跟一个｛｝用于处理当前tabkn的java代码

jjTree的使用：

jjTree的使用，需要根据实际情况写自己的Node类，但是都必须实现Node.java接口，jjTree提供一个SimpleNode.java的简单实现，也可以继承它，或者重写这个类。

给出一个javaCC自己带例子，也是四则运算：

语法定义：

 options {

  MULTI=true;

  VISITOR=true;  /*实现匹配的visitor模式代码*/

  NODE_DEFAULT_VOID=true; /* 解析函数默认不生成node类*/

}

/*jtt 默认的生成node类名，都带AST前缀加上当前解析的语意的名称*/

PARSER_BEGIN(eg4)

class eg4 {

  public static void main(String args[]) {

    System.out.println("Reading from standard input...");

    eg4 t = new eg4(System.in);

    try {

      ASTStart n = t.Start();

      eg4Visitor v = new eg4DumpVisitor();

      n.jjtAccept(v, null);

      System.out.println("Thank you.");

    } catch (Exception e) {

      System.out.println("Oops.");

      System.out.println(e.getMessage());

      e.printStackTrace();

    }

  }

}

PARSER_END(eg4)

SKIP :

{

  " "

| "\t"

| "\n"

| "\r"

| <"//" (~["\n","\r"])* ("\n"|"\r"|"\r\n")>

| <"/*" (~["*"])* "*" (~["/"] (~["*"])* "*")* "/">

}

TOKEN : /* LITERALS */

{

  < INTEGER_LITERAL:

        <DECIMAL_LITERAL> (["l","L"])?

      | <HEX_LITERAL> (["l","L"])?

      | <OCTAL_LITERAL> (["l","L"])?

  >

|

  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* >

|

  < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ >

|

  < #OCTAL_LITERAL: "0" (["0"-"7"])* >

}

TOKEN : /* IDENTIFIERS */

{

  < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >

|

  < #LETTER: ["_","a"-"z","A"-"Z"] >

|

  < #DIGIT: ["0"-"9"] >

}

ASTStart Start() #Start : {}  /* #Start生成定义的节点类，名称为 前缀 ＋ Start.Java*/

{

  Expression() ";"

  { return jjtThis; }

}

void Expression() : {}

{

  AdditiveExpression()

}

void AdditiveExpression() : {}

{

  (

    MultiplicativeExpression() ( ( "+" | "-" ) MultiplicativeExpression() )*

  ) #Add(>1)    /* Add #  当满足条件(>1)，Add生成定义的节点类，名称为 前缀 ＋ Add.Java*/

}

void MultiplicativeExpression() : {}

{

  (

    UnaryExpression() ( ( "*" | "/" | "%" ) UnaryExpression() )*

  ) #Mult(>1) /* # Mult 当满足条件(>1)，Mult生成定义的节点类，名称为 前缀 ＋ Mult.Java*/

}

void UnaryExpression() : {}

{

  "(" Expression() ")" | Identifier() | Integer()

}

void Identifier() #MyOtherID :  /* # MyOtherID生成定义的节点类，名称为 前缀 ＋ MyOtherID.Java*/

{

  Token t;

}

{

  t=<IDENTIFIER>

  {

    jjtThis.setName(t.image);

  }

}

void Integer() #Integer : {}  /* # Integer生成定义的节点类，名称为 前缀 ＋ Integer.Java*/

{

  <INTEGER_LITERAL>

}

jjDoc的使用很简单 。

如果需要生成其它语言的（例如C#）解析器，除了处理C的yacc和lex外，ANTLR（http://www.antlr.org/）也是一个不错的选择。