如何在语法上实现JJTree

使用JavaCC创建AST看起来很像创建“常规”解析器（在jj文件中定义）。如果您已有语法，那么（相对）容易:)

以下是创建AST所需的步骤：

这是一个快速的分步教程，假定您使用的是MacOS或* nix，并将javacc.jar文件与语法文件放在同一目录中，java并且javac位于系统的PATH上：

假设您的jj语法文件名为TestParser.jj，将其重命名：

mv TestParser.jj TestParser.jjt
@H_301_59@
2
现在最棘手的部分是： 装饰 语法，以便创建正确的AST结构。您可以通过在AST（或节点或生产规则（全部相同））之后添加，后跟一个标识符来 修饰
AST（或节点或生产规则）。在最初的问题中，您有很多不同的产品，这意味着您要针对不同的生产规则创建相同类型的AST：这不是您想要的。#``:``#void
如果您不 装饰 产品，则将产品名称用作节点的类型（因此，您可以删除#void）：
void decl() :
{}
{
     var_decl()
  |  const_decl()
}
@H_301_59@
现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。
现在让我们看一下（简化的）var_decl规则：
void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
             

          解决方法 

                
             
                    
              我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

              如果有帮助，以下是我的一些生产规则。提前致谢！

              void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
             

                
             


             
              
             

             

             

              
               喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
              

              
                编程之家官方1群
              
              
                编程之家官方2群
              
              
                编程之家官方3群
              
              
                编程之家官方4群

void decl() :
{}
{
     var_decl()
  |  const_decl()
}
@H_301_59@
现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。
现在让我们看一下（简化的）var_decl规则：
void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
            

          解决方法 

                
            
                    
             我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

             如果有帮助，以下是我的一些生产规则。提前致谢！

             void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
            

                
            


            
             
            

            

            

             
              喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
             

             
               编程之家官方1群
             
             
               编程之家官方2群
             
             
               编程之家官方3群
             
             
               编程之家官方4群

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
           

          解决方法 

                
           
                    
            我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

            如果有帮助，以下是我的一些生产规则。提前致谢！

            void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
           

                
           


           
            
           

           

           

            
             喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
            

            
              编程之家官方1群
            
            
              编程之家官方2群
            
            
              编程之家官方3群
            
            
              编程之家官方4群

    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
          

          解决方法 

                
          
                    
           我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

           如果有帮助，以下是我的一些生产规则。提前致谢！

           void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
          

                
          


          
           
          

          

          

           
            喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
           

           
             编程之家官方1群
           
           
             编程之家官方2群
           
           
             编程之家官方3群
           
           
             编程之家官方4群

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
         

          解决方法 

                
         
                    
          我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

          如果有帮助，以下是我的一些生产规则。提前致谢！

          void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
         

                
         


         
          
         

         

         

          
           喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
          

          
            编程之家官方1群
          
          
            编程之家官方2群
          
          
            编程之家官方3群
          
          
            编程之家官方4群

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

现在最棘手的部分是：装饰语法，以便创建正确的AST结构。您可以通过在AST（或节点或生产规则（全部相同））之后添加，后跟一个标识符来修饰 AST（或节点或生产规则）。在最初的问题中，您有很多不同的产品，这意味着您要针对不同的生产规则创建相同类型的AST：这不是您想要的。#``:``#void

如果您不装饰产品，则将产品名称用作节点的类型（因此，您可以删除#void）：

现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。

现在让我们看一下（简化的）var_decl规则：

我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：

如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：

使输入"var x : int = i;"看起来像这样：

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。

我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

如果有帮助，以下是我的一些生产规则。提前致谢！

如果您不装饰产品，则将产品名称用作节点的类型（因此，您可以删除#void）：

void decl() :
{}
{
     var_decl()
  |  const_decl()
}
@H_301_59@
现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。
现在让我们看一下（简化的）var_decl规则：
void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
            

          解决方法 

                
            
                    
             我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

             如果有帮助，以下是我的一些生产规则。提前致谢！

             void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
            

                
            


            
             
            

            

            

             
              喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
             

             
               编程之家官方1群
             
             
               编程之家官方2群
             
             
               编程之家官方3群
             
             
               编程之家官方4群

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
           

          解决方法 

                
           
                    
            我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

            如果有帮助，以下是我的一些生产规则。提前致谢！

            void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
           

                
           


           
            
           

           

           

            
             喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
            

            
              编程之家官方1群
            
            
              编程之家官方2群
            
            
              编程之家官方3群
            
            
              编程之家官方4群

    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
          

          解决方法 

                
          
                    
           我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

           如果有帮助，以下是我的一些生产规则。提前致谢！

           void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
          

                
          


          
           
          

          

          

           
            喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
           

           
             编程之家官方1群
           
           
             编程之家官方2群
           
           
             编程之家官方3群
           
           
             编程之家官方4群

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
         

          解决方法 

                
         
                    
          我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

          如果有帮助，以下是我的一些生产规则。提前致谢！

          void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
         

                
         


         
          
         

         

         

          
           喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
          

          
            编程之家官方1群
          
          
            编程之家官方2群
          
          
            编程之家官方3群
          
          
            编程之家官方4群

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。

现在让我们看一下（简化的）var_decl规则：

我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：

使输入"var x : int = i;"看起来像这样：

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

现在，该规则仅返回该AST var_decl()或返回的任何AST const_decl()。

现在让我们看一下（简化的）var_decl规则：

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void id() #ID :
{}
{
  <ID>
}

void expr() #EXPR :
{}
{
  <ID>
}
@H_301_59@
我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：
    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
           

          解决方法 

                
           
                    
            我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

            如果有帮助，以下是我的一些生产规则。提前致谢！

            void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
           

                
           


           
            
           

           

           

            
             喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
            

            
              编程之家官方1群
            
            
              编程之家官方2群
            
            
              编程之家官方3群
            
            
              编程之家官方4群

    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
          

          解决方法 

                
          
                    
           我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

           如果有帮助，以下是我的一些生产规则。提前致谢！

           void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
          

                
          


          
           
          

          

          

           
            喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
           

           
             编程之家官方1群
           
           
             编程之家官方2群
           
           
             编程之家官方3群
           
           
             编程之家官方4群

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
         

          解决方法 

                
         
                    
          我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

          如果有帮助，以下是我的一些生产规则。提前致谢！

          void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
         

                
         


         
          
         

         

         

          
           喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
          

          
            编程之家官方1群
          
          
            编程之家官方2群
          
          
            编程之家官方3群
          
          
            编程之家官方4群

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：

使输入"var x : int = i;"看起来像这样：

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

我用这种#VAR类型装饰。现在这意味着该规则将返回以下树结构：

    VAR 
   / | \
  /  |  \
ID  ID  EXPR
@H_301_59@
如您所见，终端从AST中被丢弃了！这也意味着id和expr规则会松开其<ID>终端匹配的文本。当然，这不是您想要的。对于需要使终端的内部文本保持匹配的规则，您需要.value将树的显式设置.image为匹配的终端的：
void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
          

          解决方法 

                
          
                    
           我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

           如果有帮助，以下是我的一些生产规则。提前致谢！

           void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
          

                
          


          
           
          

          

          

           
            喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
           

           
             编程之家官方1群
           
           
             编程之家官方2群
           
           
             编程之家官方3群
           
           
             编程之家官方4群

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
         

          解决方法 

                
         
                    
          我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

          如果有帮助，以下是我的一些生产规则。提前致谢！

          void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
         

                
         


         
          
         

         

         

          
           喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
          

          
            编程之家官方1群
          
          
            编程之家官方2群
          
          
            编程之家官方3群
          
          
            编程之家官方4群

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

使输入"var x : int = i;"看起来像这样：

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
使输入"var x : int = i;"看起来像这样：
       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
         

          解决方法 

                
         
                    
          我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

          如果有帮助，以下是我的一些生产规则。提前致谢！

          void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
         

                
         


         
          
         

         

         

          
           喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
          

          
            编程之家官方1群
          
          
            编程之家官方2群
          
          
            编程之家官方3群
          
          
            编程之家官方4群

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

使输入"var x : int = i;"看起来像这样：

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

使输入"var x : int = i;"看起来像这样：

       VAR 
        |
    .---+------.
   /    |       \
  /     |        \
ID["x"] ID["int"] EXPR["i"]
@H_301_59@
这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：
// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
        

          解决方法 

                
        
                    
         我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

         如果有帮助，以下是我的一些生产规则。提前致谢！

         void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
        

                
        


        
         
        

        

        

         
          喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
         

         
           编程之家官方1群
         
         
           编程之家官方2群
         
         
           编程之家官方3群
         
         
           编程之家官方4群

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

这就是您为AST创建合适的结构的方式。下面是一个小的语法，它是您自己的语法的非常简单的版本，其中包括一个main测试所有语法的小方法：

// TestParser.jjt
PARSER_BEGIN(TestParser)

public class TestParser {
  public static void main(String[] args) throws ParseException {
    TestParser parser = new TestParser(new java.io.StringReader(args[0]));
    SimpleNode root = parser.program();
    root.dump("");
  }
}

PARSER_END(TestParser)

TOKEN :
{
   < OPAR  : "(" > 
 | < CPAR  : ")" >
 | < OBR   : "{" >
 | < CBR   : "}" >
 | < COL   : ":" >
 | < SCOL  : ";" >
 | < COMMA : "," >
 | < VAR   : "var" >
 | < EQ    : "=" > 
 | < CONST : "const" >
 | < ID    : ("_" | <LETTER>) ("_" | <ALPHANUM>)* >
}

TOKEN :
{
   < #DIGIT    : ["0"-"9"] >
 | < #LETTER   : ["a"-"z","A"-"Z"] >
 | < #ALPHANUM : <LETTER> | <DIGIT> >
}

SKIP : { " " | "\t" | "\r" | "\n" }

SimpleNode program() #PROGRAM :
{}
{
  (decl())* (function())* <EOF> {return jjtThis;}
}

void decl() :
{}
{
     var_decl()
  |  const_decl()
}

void var_decl() #VAR :
{}
{
  <VAR> id() <COL> id() <EQ> expr() <SCOL>
}

void const_decl() #CONST :
{}
{
  <CONST> id() <COL> id() <EQ> expr() <SCOL>
}


void function() #FUNCTION :
{}
{
  type() id() <OPAR> params() <CPAR> <OBR> /* ... */ <CBR>
}

void type() #TYPE :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void id() #ID :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void params() #PARAMS :
{}
{
  (param() (<COMMA> param())*)?
}

void param() #PARAM :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}

void expr() #EXPR :
{Token t;}
{
  t=<ID> {jjtThis.value = t.image;}
}
@H_301_59@
3
让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：
java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
       

          解决方法 

                
       
                    
        我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

        如果有帮助，以下是我的一些生产规则。提前致谢！

        void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
       

                
       


       
        
       

       

       

        
         喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
        

        
          编程之家官方1群
        
        
          编程之家官方2群
        
        
          编程之家官方3群
        
        
          编程之家官方4群

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

让jjtree该类（包含在中javacc.jar）jj为您创建一个文件：

java -cp javacc.jar jjtree TestParser.jjt
@H_301_59@
4
上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：
java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
      

          解决方法 

                
      
                    
       我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

       如果有帮助，以下是我的一些生产规则。提前致谢！

       void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
      

                
      


      
       
      

      

      

       
        喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
       

       
         编程之家官方1群
       
       
         编程之家官方2群
       
       
         编程之家官方3群
       
       
         编程之家官方4群

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

上一步已创建文件TestParser.jj（如果一切正常）。让javacc（也存在于中javacc.jar）对其进行处理：

java -cp javacc.jar javacc TestParser.jj
@H_301_59@
5
要编译所有源文件，请执行以下操作：
javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
     

          解决方法 

                
     
                    
      我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

      如果有帮助，以下是我的一些生产规则。提前致谢！

      void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
     

                
     


     
      
     

     

     

      
       喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
      

      
        编程之家官方1群
      
      
        编程之家官方2群
      
      
        编程之家官方3群
      
      
        编程之家官方4群

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

要编译所有源文件，请执行以下操作：

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

要编译所有源文件，请执行以下操作：

javac -cp .:javacc.jar *.java
@H_301_59@
（在Windows上，做的：javac -cp .;javacc.jar *.java）
6
关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：
var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
    

          解决方法 

                
    
                    
     我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

     如果有帮助，以下是我的一些生产规则。提前致谢！

     void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
    

                
    


    
     
    

    

    

     
      喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
     

     
       编程之家官方1群
     
     
       编程之家官方2群
     
     
       编程之家官方3群
     
     
       编程之家官方4群

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

（在Windows上，做的：javac -cp .;javacc.jar *.java）

关键时刻已经到来：让我们看看一切是否真的有效！要让解析器处理输入：

var n : int = I;

const x : bool = B;

double f(a,b,c) 
{ 
}
@H_301_59@
执行以下命令：
java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
   

          解决方法 

                
   
                    
    我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

    如果有帮助，以下是我的一些生产规则。提前致谢！

    void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
   

                
   


   
    
   

   

   

    
     喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
    

    
      编程之家官方1群
    
    
      编程之家官方2群
    
    
      编程之家官方3群
    
    
      编程之家官方4群

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

执行以下命令：

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

执行以下命令：

java -cp . TestParser "var n : int = I; const x : bool = B; double f(a,b,c) { }"
@H_301_59@
并且应该在控制台上看到以下内容：
程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
  

          解决方法 

                
  
                    
   我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

   如果有帮助，以下是我的一些生产规则。提前致谢！

   void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
  

                
  


  
   
  

  

  

   
    喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
   

   
     编程之家官方1群
   
   
     编程之家官方2群
   
   
     编程之家官方3群
   
   
     编程之家官方4群

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

并且应该在控制台上看到以下内容：

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

并且应该在控制台上看到以下内容：

程序
 删除
  VAR
   ID
   ID
   EXPR
 删除
  CONST
   ID
   ID
   EXPR
 功能
  类型
  ID
  参数
   参数
   参数
   参数
@H_301_59@
请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。
高温超导
编辑
对于包含表达式的有效语法，您可以看一下我的以下表达式评估器：https：//github.com/bkiers/Curta（语法在中src/grammar）。您可能想看看在二进制表达式的情况下如何创建根节点。
 

          解决方法 

                
 
                    
  我有一个任务，要使用JavaCC为讲师提供的语言制作具有语义分析的自上而下的解析器。我已经写了生产规则，没有错误。我完全陷入了如何在代码中使用JJTree的问题，而我花大量时间在互联网上搜索教程的时间也没有吸引我。只是想知道有人可以花点时间来解释如何在代码中实现JJTree吗？或者，如果某个地方有隐藏的分步教程，那将对您有很大的帮助！

  如果有帮助，以下是我的一些生产规则。提前致谢！

  void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

                
 

                
 


 
  
 

 

 

  
   喜欢与人分享编程技术与工作经验，欢迎加入编程之家官方交流群！
  

  
    编程之家官方1群
  
  
    编程之家官方2群
  
  
    编程之家官方3群
  
  
    编程之家官方4群

void program() : {}
{
  (decl())* (function())* main_prog()
}

void decl() #void : {}
{
  (
    var_decl() | const_decl()
   )
}

void var_decl() #void : {}
{
  <VAR> ident_list() <COLON> type()
 (<COMMA> ident_list() <COLON> type())* <SEMIC>
}

void const_decl()  #void : {}
{
  <CONSTANT> identifier() <COLON> type() <EQUAL> expression()
 ( <COMMA> identifier() <COLON> type() <EQUAL > expression())* <SEMIC>
}

void function() #void : {}
{
  type() identifier() <LBR> param_list() <RBR>
  <CBL>
  (decl())*
  (statement() <SEMIC> )*
  returnRule() (expression() | {} )<SEMIC>
  <CBR>
}

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

如果有帮助，以下是我的一些生产规则。提前致谢！

请注意，您看不到ID匹配的文本，但请相信我，它们在那里。该方法dump()只是不显示它。

高温超导

其他 2022/1/1 18:14:58 有681人围观

撰写回答

你尚未登录，登录后可以

和开发者交流问题的细节

关注并接收问题和回答的更新提醒

参与内容的编辑和改进，让解决方法与时俱进

请先登录