JavaCC -简单表达式

Question

如果可能的话，应该根据图像解析字符串输入。

SKIP :
{
< " " | "\t" | "\r" | "\n" | "\r\n" >
| <"//" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
| <"/*"(~["/"])*  "*""/" >
}
TOKEN : { < VAR: "VAR" > }
TOKEN : { < AS: "AS" >}
TOKEN : /* KEYWORDS */
{
    < TYPE: "INT"| "BOOL"|"FLOAT" >
}

TOKEN :
{
  < EQUALS: "=" >
}
TOKEN:
{
  < PLUS : "+" >|< MINUS :"-" >|< MUL: "*" >|< DIV: "/" >|< COMM: ",">
}
TOKEN:
{
    < VARIABLE: (["a"-"z", "A"-"Z", "0"-"9"])+ >
}

void decleration(): {} { <VAR> (<VARIABLE>|< COMM >|<EQUALS>)+ <AS> <TYPE>}

我还是JavaCC新手，所以请原谅我的代码很糟糕，我在哪里可以找到一些关于使用JavaCC制作自定义编译器的来源。

谢谢。

Answer 1

有一个教程这里。

要分析问题中给出的示例，您需要：

• 若要在令牌TYPE中添加"CHAR“，
• 要在令牌VARIABLE中添加"_“，请执行以下操作。实际上，我会重写它，因为它也接受整数。我会这样做：

记号：{<变量：(X)*><<#字母："a"-"z"，"A"-"Z"，"_“><<#位数："0"-"9”>}

• 若要为声明列表添加非终端生产方法，请执行以下操作：

空输入()：{} {(声明())*}

• 为初始值添加令牌。这可能是一个复杂的表达式，但至少需要INT、CHAR、FLOAT和字符串的文字值(如示例中的"TRUE“)：

令牌：{< INT_VALUE：()+ >\< FLOAT_VALUE： ".“()* ".”()+ >< CHAR_VALUE："\'“(~”"\"“，"\”)“\”>< STRING_VALUE：“\”(~“\”)，“\”*“><<\”，"n"，"t"，"b“、"r”、"f“、"\”、“\”、“”}

• 为变量初始值添加生产规则：

void varDeclaration()：{} {( literalValue())？} void literalValue()：{} {}{ \x / _ }

声明规则成为：

{} { varDeclaration() (< COMM > varDeclaration())* }

注意，当您跳过行字符的末尾时，没有什么可以阻止在同一行上出现多个声明。

生成的文件如下所示：

选项{静态=假；OUTPUT_DIRECTORY =“src/解析器”；}PARSER_BEGIN(解析器)包解析器；公共类解析器{公共空解析器()抛出ParseException { input()；} PARSER_END(Parser)跳过：{<“x”/ (~"\n“)，"\r")* (“\n”-“\r”-“\r”)>“>)令牌：{< PLUS："+”>|<减号：-“>|< MUL："*”>|< DIV："/“>|< COMM："，"> }记号：{< INT_VALUE：()* ><#字母："a"-"z"，“A”-“-”Z“，"_”><#位数："0"-"9“}令牌：{<< FLOAT_VALUE：()+ >”。< STRING_VALUE：“\\”(~“\\”，"\“)*”\“><\”\“<#转义："\"”n"，"t"，"b"，"r"，"f"，"\"，“\”，“\‘>} void ()：{} {(声明())*} void varDeclaration()：{} {( literalValue())？}literalValue()}{ } void ()声明()：{} { varDeclaration() (< COMM > varDeclaration())* }

更新

添加主体部分；据我所见，输入是一个声明列表，后面跟着一个主体：

空输入()：{} {(声明())* body() }

身体法则应该是这样的：

void body(): {} { <START> (statement())* <STOP> }

您还需要一些标记:关键字"START“、"STOP”、"OUTPUT“、"AND”、"OR“、"NOT”、运算符：“、"&”&“、"(”、")“等等.

我看到两种类型的陈述:赋值和输出语句：

void statement(): {} { assignment() | output() }
void assignment(): {} { <VARIABLE> <EQUALS> expression() }
void output(): {} { <OUTPUT> <COLON> expression() }

它们都需要表达式的规则。看起来可能是这样的：

void expression(): {} { comparison() (logicalOp() comparison())* }
void logicalOp(): {} { <AND> | <OR> }
void comparison(): {} { simpleExpression() ( comparisonOp() simpleExpression() )? }
void comparisonOp(): {} { <LT> | <GT> | <LE> | <GE> | <EQ> | <NE> }
void simpleExpression(): {} { term() ( addOp() term() )* }
void addOp(): {} { <PLUS> | <MINUS> | <CAT> }
void term(): {} { factor() ( mulOp() factor() )* }
void mulOp(): {} { <MUL> | <DIV> | <MOD> }
void factor(): {} {
    (<PLUS>|<MINUS>) factor()
    | <LPAR> expression() <RPAR>
    | <NOT> expression()
    | <VARIABLE>
    | literalValue()
}

把这一切结合在一起：

options {
    STATIC = false;
    OUTPUT_DIRECTORY = "src/parser";
}
PARSER_BEGIN(Parser)
package parser;
public class Parser {
    public void parse() throws ParseException {
        input();
    }
}
PARSER_END(Parser)

SKIP :
{
< " " | "\t" | "\r" | "\n" | "\r\n" >
| <"//" (~["\n","\r"])* ("\n"|"\r"|"\r\n") >
| <"/*"(~["/"])*  "*""/" >
}
TOKEN : { < VAR: "VAR" > }
TOKEN : { < AS: "AS" >}
TOKEN : { < START: "START" > | < STOP: "STOP" > | < OUTPUT: "OUTPUT" > } 
TOKEN : /* KEYWORDS */
{
    <INT: "INT">|<BOOL:"BOOL">|<FLOAT:"FLOAT">|<CHAR:"CHAR">
    |<AND: "AND"> | <OR: "OR"> | <NOT: "NOT">
}

TOKEN :
{
  < EQUALS: "=" > | < COLON: ":" > | <LPAR: "(">|<RPAR: ")">
}
TOKEN:
{
  < PLUS : "+" >|< MINUS :"-" >|< MUL: "*" >|< DIV: "/" >|< MOD: "%" >|< COMM: ",">
  |<LT: "<">|<GT: ">">|<LE: "<=">|<GE: ">=">|<EQ: "==">|<NE: "<>">
  |<CAT: "&">
}
TOKEN:
{
    < VARIABLE: <LETTER>(<LETTER>|<DIGIT>)* >
    | < #LETTER: ["a"-"z", "A"-"Z", "_"] >
    | < #DIGIT: ["0"-"9"] >
}
TOKEN:
{
    < INT_VALUE: (<DIGIT>)+ >
    | < FLOAT_VALUE: <INT_VALUE> "." (<DIGIT>)* | "." (<DIGIT>)+ >
    | < CHAR_VALUE: "\'" (~["\'","\\"]|<ESCAPE>) "\'" >
    | < STRING_VALUE: "\"" (~["\"","\\"]|<ESCAPE>)* "\"" >
    | < #ESCAPE: "\\" ["n","t","b","r","f","\\","\"","\'"] >
}

void input(): {} { (declaration())*  body() }
void varDeclaration(): {} { <VARIABLE> (<EQUALS> literalValue())?  }
void literalValue(): {} { <INT_VALUE> | <FLOAT_VALUE> | <CHAR_VALUE> | <STRING_VALUE> }
void declaration(): {} { <VAR> varDeclaration() (<COMM> varDeclaration())* <AS> type()}
void type(): {} {<INT>|<FLOAT>|<BOOL>|<CHAR>}
void body(): {} { <START> (statement())* <STOP> }
void statement(): {} { assignment() | output() }
void assignment(): {} { <VARIABLE> <EQUALS> expression() }
void output(): {} { <OUTPUT> <COLON> expression() }
void expression(): {} { comparison() (logicalOp() comparison())* }
void logicalOp(): {} { <AND> | <OR> }
void comparison(): {} { simpleExpression() ( comparisonOp() simpleExpression() )? }
void comparisonOp(): {} { <LT> | <GT> | <LE> | <GE> | <EQ> | <NE> }
void simpleExpression(): {} { term() ( addOp() term() )* }
void addOp(): {} { <PLUS> | <MINUS> | <CAT> }
void term(): {} { factor() ( mulOp() factor() )* }
void mulOp(): {} { <MUL> | <DIV> | <MOD> }
void factor(): {} {
    (<PLUS>|<MINUS>) factor()
    | <LPAR> expression() <RPAR>
    | <NOT> expression()
    | <VARIABLE>
    | literalValue()
}