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范式为：

Expression
::=
( ( <NEWLINE> )* Simple_Expression <NEWLINE> )* <EOF>

Simple_Expression
::=
Term ( addop Term )*

addop
::=
<PLUS>



<MINUS>

Term
::=
Factor ( mulop Factor )*

mulop
::=
<TIMERS>



<OVER>

Factor
::=
<ID>



<NUM>



<MINUS>



<PLUS>



<LPAREN> Simple_Expression <RPAREN>




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

/* 运行 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自己带例子，也是四则运算：

语法定义：

Start
::=
Expression ";"

Expression
::=
AdditiveExpression

AdditiveExpression
::=
( MultiplicativeExpression ( ( "+" "-" ) MultiplicativeExpression )* )

MultiplicativeExpression
::=
( UnaryExpression ( ( "*" "/" "％" ) UnaryExpression )* )

UnaryExpression
::=
"(" Expression ")"



Identifier



Integer

Identifier
::=
<IDENTIFIER>

Integer
::=
<INTEGER_LITERAL>






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/）也是一个不错的选择。