javacc 如何配置token正则表达式

最新推荐文章于 2023-04-14 09:42:38 发布
最新推荐文章于 2023-04-14 09:42:38 发布
阅读量4.3k 收藏 2
点赞数
分类专栏： javacc 文章标签： token null string bt stream equals
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyb243380456/article/details/7281246
版权 
/************************************************************************/
>说明:这段代码经过几天的不断报错得到的经验
      代码可以直接考到自己的工作目录下进行运行。
/************************************************************************/

/************************************************************************/
options
{
  NODE_USES_PARSER = true;
  JDK_VERSION = "1.5";
  MULTI = true;
  VISITOR = true;
  NODE_DEFAULT_VOID = false;
  STATIC = true;
  USER_CHAR_STREAM = false;
  UNICODE_INPUT = true;
  JAVA_UNICODE_ESCAPE = true;
}
PARSER_BEGIN(eg2)

public class eg2
{
}

PARSER_END(eg2)

TOKEN:{
   < #SHIT: (~[" "])+ > //如果这里不加#就会和下面的S冲突并报出:
//并且这可以在调试这段代码的时候可以找到这个错误如果返回的token类型不是你想要的肯定有token类型冲突没解决
//需要继续找token冲突的问题
 
//static private int jj_ntk() {
//    if ((jj_nt=token.next) == null)
//      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
//    else
//      return (jj_ntk = jj_nt.kind);
//  }

//解决办法:
//>根据当前tokenmanager返回的字符的类型和当前发送冲突的字符类型的token定义进行对比
//>马上就可以找到错误所在了
//ParseException: Encountered " <SHIT> "abbba "" at line 1, column 1.
//Was expecting one of:
//    <EOF> 
//    <S> ...
//	at eg2.generateParseException(eg2.java:222)
//	at eg2.jj_consume_token(eg2.java:160)
//	at eg2.test(eg2.java:30)
//	at X.main(X.java:26)

  |<S:(~[" ","~","^"])+>
  |<#Y:(~[" "])+> 
}

void test():
{
  Token t = null;
}
{
 (
   t = < S><EOF >
   {
   System.out.println(t);
 }
 |
  < EOF >
  {
    return;
  }
 )
}
/************************************************************************/


/************************************************************************/
>测试代码部分以及总结出现的问题
 有些token要定义成局部的这样就不会和全局的起冲突
 如何解决token冲突的问题是javacc最难的问题
/************************************************************************/

import java.io.StringReader;
public class X {

/**********************/
//>总结
//+一次或者多次
//["A"]表示只可以出现一个字符
//如果想[2012-200000]这样的东西
//我想要匹配第一个[如果硬是匹配不上那么肯定是别的token也包含了他
//并且不能映射到他的身上来要注意如果不能取到单个字符就报错说明有其他东西也包括了他
/**********************/


/**********************/
//同样的代码在两个jjt文件中进行对比验证但是定义的token不同也产生的效果不同
//怎么将token区分开来才不会报错 当你想取到15的token
//的时候突然取到字符窜的第一个字符正好是7类型的token那么肯定会报错报告类型
//不同字符匹配在开始第一个字母怎么去区分于其他字符很重要
/**********************/


/**********************/
//就如:
//<S:([" ","~","^"])+>
//<Y:([" "])+)> 

//需要在生产表达式中用的才搞成全局的不然都要局部的
//< TERM_KEY:(~[" ","="])+ >不能以" "或者=开头但是可以以=或者空格结尾
//首先取出一个字符找到最匹配的token类型然后在继续
/**********************/


/**********************/
//需要注意的是SKIP不要随便就用自动生成的要定制或者不需要
//定义TOKEN的时候有些要定义成局部的这样发生冲突的可能性会小很多
/**********************/


/**********************/
	public static void main(String[] args) {
		try {
			eg2 e = new eg2(new StringReader("abbba"));
			e.test();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
/**********************/

}
/************************************************************************/



/************************************************************************/

options
{
  NODE_USES_PARSER = true;/** 是否每个节点拥有解析器的引用*/
  JDK_VERSION = "1.5";
  MULTI = true;/** 是否生成不同的节点*/
  VISITOR = true;/** 是否使用观察者模式*/
  NODE_DEFAULT_VOID = false;/** 是否将每个生产表达式生成节点*/
  STATIC = true;/** 生成的成产表达式是否全部为静态*/
  USER_CHAR_STREAM = false;/**是否使用自定义的字符刘 */
  UNICODE_INPUT = true;
  JAVA_UNICODE_ESCAPE = true;
}

PARSER_BEGIN(MyParser)

public class MyParser
{
 public static String tname="";/** 当前字段名称*/
 public static StringBuffer sb=new StringBuffer();/** 查询语句拼接*/
 public static int def_opr=10;/** 当前查询单元和下一个查询单元的关系*/
 public static boolean need_conj=false;/** 是否需要关系*/
}

PARSER_END(MyParser)

/************************************/
/*===========私有字符定义============*/
/************************************/
TOKEN :
{
  < #_TERM_START : ~[ " ", "~", "-", "+", "{", "}", "[", "]", ":", "!","=","(", "-", ",", "^", ")" ] >
| < #_NUMBER_CHAR : [ "0"-"9" ] >
| < #_ALPHABET_CHAR :
    (
      [ "A"-"Z" ]
    | [ "a"-"z" ]
    ) >
| <#_ESCAPED_CHAR: "\\" ~[] >
| <#_TERM_CHAR:(<_TERM_START> | <_ESCAPED_CHAR> | "-" | "+" ) >
}


/************************************/
/*===========公共字符定义============*/
/************************************/


/** 括号字符定义*/
TOKEN :
{
  < LPAREN:(" ")*"["(" ")*>
| < LBRACE:(" ")*"("(" ")*>
| < LSHIT:(" ")*"{"(" ")*>
| < RPAREN:(" ")*"]"(" ")*>
| < RBRACE:(" ")*")">
| < RSHIT:(" ")*"}"(" ")* >
}

/** 查询单元关系连接符定义*/
TOKEN :
{
  < AND :
    (
     (" ")*"AND"(" ")*
    | (" ")*"And" (" ")*
    | (" ")* "ANd" (" ")*
    | (" ")*"AnD"(" ")*
    |(" ")*  "aNd" (" ")*
    |  (" ")*"anD"(" ")*
    | (" ")*"and"(" ")*
    |(" ")*  "+"(" ")*
    |  (" ")*"&&"(" ")*
    ) >
| < OR :
    (
      (" ")* "OR" (" ")*
    | (" ")* "Or" (" ")*
    | (" ")* "oR" (" ")*
    | (" ")* "or" (" ")*
    | (" ")* "," (" ")*
    | (" ")* "||" (" ")*
    ) >
| < NOT :
    (
      (" ")* "NOT" (" ")*
    | (" ")* "not" (" ")*
    | (" ")* "Not" (" ")*
    | (" ")* "nOt" (" ")*
    | (" ")* "nOT" (" ")*
    | (" ")* "NOt" (" ")*
    | (" ")* "noT" (" ")*
    ) >
}


/** 单元权重定义*/
TOKEN :
{
  < CARAT : (" ")* "^" (" ")* > : Bt
}

< Bt >
TOKEN :
{
  < NUMBER :
    (< _NUMBER_CHAR >)+
    (
      "." (< _NUMBER_CHAR >)+
    )? >
  : DEFAULT
}

/** 关键词之间可以隔开多少个字符定义*/
TOKEN :
{
  < FUZZY_SLOP :"~"> :Bt
}

/** 查询单元名字以及查询关键词定义*/
TOKEN :
{
  < EQUALS : (" ")* "=" (" ")* >
| <TERM: (" ")* <_TERM_START> (<_TERM_CHAR>)* (" ")* >
}

/** 范围查询中间连接符定义*/
TOKEN :
{
  < RANGE_TO :
    (
      "to"
    | "TO"
    | "To"
    | (" ")* "tO" (" ")*
    | (" ")* "~" (" ")*
    | (" ")* "-" (" ")*
    ) >
}

/** 字母定义*/
TOKEN :
{
  < ALPHABET : (< _ALPHABET_CHAR >)+ >
}




//name=(
//zhangsan And NOT([2011-2012] OR zhangsan*)

//name=
//zhangsan and lisi not(wang zhaoliu)

//(name=

//将逻辑集中的生产表达式内部分为多个生产表达式而不直接使用token表达式进行逻辑判断


/** 解析开始*/
options
{
  NODE_USES_PARSER = true;
  JDK_VERSION = "1.5";
  MULTI = true;
  VISITOR = true;
  NODE_DEFAULT_VOID = false;
  STATIC = true;
  USER_CHAR_STREAM = false;
  UNICODE_INPUT = true;
  JAVA_UNICODE_ESCAPE = true;
}

PARSER_BEGIN(MyParser)
package com.zyb;

public class MyParser
{
 public static String tname="";/** 当前字段名称*/
 public static StringBuffer sb=new StringBuffer();/** 查询语句拼接*/
 public static String conj="";/** 第一个单元和第二个单元的关系*/
 public static StringBuffer cpl=new StringBuffer();/** 保存用于块查询的查询表达式*/
 
 
}

PARSER_END(MyParser)

/************************************/
/*===========私有字符定义============*/
/************************************/
TOKEN :
{
  < #_TERM_START : ~[ " ", "~", "-", "+", "{", "}", "[", "]", ":", "!","=","(", "-", ",", "^", ")", ">" ,"<"] >
| < #_NUMBER_CHAR : [ "0"-"9" ] >
| < #_ALPHABET_CHAR :
    (
      [ "A"-"Z" ]
    | [ "a"-"z" ]
    ) >
| <#_ESCAPED_CHAR: "\\" ~[] >
| <#_TERM_CHAR:(<_TERM_START> | <_ESCAPED_CHAR> | "-" | "+" ) >
}


/************************************/
/*===========公共字符定义============*/
/************************************/


/** 括号字符定义*/
TOKEN :
{
  < LPAREN:(" ")*"["(" ")*>
| < LBRACE:(" ")*"("(" ")*>
| < LSHIT:(" ")*"{"(" ")*>
| < RPAREN:(" ")*"]"(" ")*>
| < RBRACE:(" ")*")"(" ")*>
| < RSHIT:(" ")*"}"(" ")* >
}

/** 查询单元关系连接符定义*/
TOKEN :
{
  < AND :
    (
      (" ")*"AND"(" ")*
    | (" ")*"And"(" ")*
    | (" ")* "ANd"(" ")*
    | (" ")*"AnD"(" ")*
    | (" ")*"aNd"(" ")*
    | (" ")*"anD"(" ")*
    | (" ")*"and"(" ")*
    | (" ")*"+"(" ")*
    | (" ")*"&&"(" ")*
    ) >
| < OR :
    (
      (" ")* "OR" (" ")*
    | (" ")* "Or" (" ")*
    | (" ")* "oR" (" ")*
    | (" ")* "or" (" ")*
    | (" ")* "," (" ")*
    | (" ")* "||" (" ")*
    ) >
| < NOT :
    (
      (" ")* "NOT" (" ")*
    | (" ")* "not" (" ")*
    | (" ")* "Not" (" ")*
    | (" ")* "nOt" (" ")*
    | (" ")* "nOT" (" ")*
    | (" ")* "NOt" (" ")*
    | (" ")* "noT" (" ")*
    ) >
}


/** 单元权重定义*/
TOKEN :
{
  < CARAT : (" ")* "^" (" ")* > : Bt
}

< Bt >
TOKEN :
{
  < NUMBER :
    (< _NUMBER_CHAR >)+
    (
      "." (< _NUMBER_CHAR >)+
    )? >
  : DEFAULT
}

/** 关键词之间可以隔开多少个字符定义*/
TOKEN :
{
  < FUZZY_SLOP :"~"> :Bt
}

/** 查询单元名字以及查询关键词定义*/
TOKEN :
{
  < EQUALS : (" ")* "=" (" ")* >
| <TERM:  <_TERM_START> (<_TERM_CHAR>)* >
}

/** 范围查询中间连接符定义*/
TOKEN :
{
  < RANGE_TO :
    (
      (" ")*"to"(" ")*
    | (" ")*"TO"(" ")*
    | (" ")*"To"(" ")*
    | (" ")*"tO"(" ")*
    | (" ")*"~"(" ")*
    | (" ")*"-"(" ")*
    ) >
}
//TOKEN:{
//  < CMPLEX_TERM:<TERM >(< COMPLEX> |< SPACE> |< NEAR>) >
//}

/** 字母定义*/
TOKEN :
{
  < ALPHABET : (< _ALPHABET_CHAR >)+ >
}

//motor w3 golv
//drive wf3 train
//top near hat
//space 空格
//((polymerase wf4 chain)wf2 reaction)
TOKEN:{
      <#_W:("W"|"w") >
   |<#_F:("F"|"f") >
   |<SPACE:(" ")*(("S"|"s")("p"|"P")("a"|"A")("C"|"c")("e"|"E"))(" ")* > /** 定义space不同大小写的形势*/
   |<NEAR:(" ")*(("N"|"n")("e"|"E")("a"|"A")("r"|"R"))(" ")* >
   |<#_CMP:(" ")*(<_W >|<_F >|(<_W ><_F >))< NUMBER>(" ")* > 
   |<COMPLEX:(" ")*< _CMP>(" ")*>
   |<TERM_COMPLEX:(< TERM>(<COMPLEX >|< SPACE>|< NEAR>)) > 
}


/** 解析开始*/
ASTstart start():
{
}
{
{
  jjtThis.value="";
}
(
   //start with (
  start_with_lbrace()
  |
   //start witch )
  start_with_rbrace()
  | 
   //start with name=(
  (
    LOOKAHEAD(3)
      simple_wt()
  |term_elements()
  )
 |conjun_element()
 | < EOF >
  {
   return jjtThis;
  } 
)
{
  return jjtThis;
}
}
/** 如何递归调用自己*/
void complex_term():
{
  Token t1=null;
  Token t2=null;
  Token cmp1=null;
  Token lb=null;
  Token rb=null;
  String bf="";
}
{
{
  tname="";
}
      (t1=<TERM >{cpl.append(t1);complex_term();}
      |<LBRACE>{cpl.append("(");complex_term();}
      |(cmp1 = < COMPLEX>{cpl.append(cmp1);complex_term();}
      |cmp1 = < SPACE>{cpl.append(cmp1);complex_term();}
      |cmp1=< NEAR>{cpl.append(cmp1);complex_term();})
      |<RBRACE>{cpl.append(")");complex_term();}
      |bf=bf(){start();}
      )
}

//[..]表示可以有可无
//(...)表示必须有一个
void range():
{
  String bf = "";
  Token t1 = null;
  Token t2 = null;
  Token lparen = null;
  Token rparen=null;
}
{
   (lparen = < LPAREN > |lparen=< LSHIT>)
    (t1 = <TERM >)
        < RANGE_TO >
    (t2= <TERM >)
    (rparen = < RPAREN > |rparen = < RSHIT>)
    bf = bf()
   {
       jjtThis.value=conj+tname+":"+lparen.toString().trim()+t1.toString().trim()+" TO "+t2.toString().trim()+rparen.toString().trim()+bf;
       sb.append(conj+tname+":"+lparen.toString().trim()+t1.toString().trim()+" TO "+t2.toString().trim()+rparen.toString().trim()+bf);
       start();
   }
}


void conjun_element():
{
}
{
 (
     (
     < AND >
     {
        jjtThis.value=" + ";
        conj = " + ";
     }
    )
  |
    (
      < OR >
      {
        jjtThis.value="OR ";
        conj = "OR ";
      }
    )
  |
  (
   < NOT >
  {
    jjtThis.value="- ";
    conj="- ";
  }
  )
 )
 {
   start();
 }
}

void term_elements():
{
}
{
  {
    jjtThis.value="";
  }
 (
   (
    LOOKAHEAD(2)
    start_with_nameEqu()
   |(
      LOOKAHEAD(2)
       special_term()
      |simple_term()
     )
  )
  |range()
 )
}

TOKEN:{
  < G_TTER:(" ")*">"(" ")* >
 |< L_TTLE:(" ")*"<" (" ")* >  
}

void special_term():
{
  Token t = null;
  String bf = null;
  Token symbole=null;
  Token v = null;
}
{
  t= < TERM >(symbole = <G_TTER >|symbole = <L_TTLE >) v = < TERM> bf = bf()
  {
        tname=t.toString().trim();
        jjtThis.value=conj+tname+symbole.toString().trim()+v.toString()+bf;
        sb.append(conj+tname+t.toString().trim()+symbole.toString().trim()+bf);
        start();
  }
}

String bf():
{
 Token t = null; 
}
{
  [< FUZZY_SLOP> t = < NUMBER >
  {
     jjtThis.value="~"+t;
    return "~"+t.toString().trim();
  } | < CARAT > t =< NUMBER>
  {
    jjtThis.value="^"+t;
    return "^"+t.toString().trim();
  }]//可以出现也可以不出现
  {
    jjtThis.value="";
    return "";
  }
}

void simple_term():
{
  Token t = null;
  String bf = "";
}
{
 t = < TERM> bf = bf()
  {
    jjtThis.value=conj+tname+":"+t.toString().trim()+bf;
    sb.append(conj+tname+":"+t.toString().trim()+bf+" ");
    start();
  }
}


void simple_wt():
{
  Token n = null;
}
{
  (
    n = < TERM><EQUALS ><LBRACE >
    {
    tname=n.toString().trim();
    jjtThis.value="(";
    sb.append(" ( ");
    cpl.append(tname+"(");
    start();
  }
    |n = < TERM_COMPLEX >
    {
      cpl.append(n);
      complex_term();
      return;
    }
  )
}

void start_with_nameEqu():
{
  Token n = null;
}
{
  n=< TERM><EQUALS >
  {
    tname=n.toString().trim();
    jjtThis.value=tname;
    start();
  }
}

void start_with_lbrace():
{
}
{
  < LBRACE >
  {
    sb.append(conj+" ( ");
    jjtThis.value=conj+" ( ";
    conj=" ";
    start();
  }
}

void start_with_rbrace():
{
}
{
  < RBRACE >
  {
    sb.append(" ) ");
    jjtThis.value=" ) ";
    start();
  }
}

/***********************************************************************/


2哥的成长记录
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
javacc四则运算表达式计算器
05-11
本程序实现一个四则混合运算，用户只需要输入四则混合运算表达式，程序自动计算， 可以一次计算一个表达式，也可以批量计算多行表达式，而且适合商业计算精度要求。...清屏功能失效,表达式解析部分使用javacc来编译。
javacc 名词解释 如token,specialToken,lookahead
02-09
javacc 名词解释 如token,specialToken,lookahead
【JAVA】基于Token的用户验证
逛街的喵啊
07-23 1万+
背景 传统的用户验证是基于session自身的特性实现，当用户提交登陆请求，后台验证通过后，会在session中留下用户的信息，用于识别当前用户在客户端登陆了。通常而言session都是保存在内存中，而随着认证用户的增多，服务端的开销会明显增大。因为认证的记录是保存在内存中，意味着用户下次请求还必须要请求在这台服务器上,这样才能拿到授权的资源，这样在分布式的应用上，相应的限制了负载均衡器的能力。......
java正则表达式（很全）个人学习总结
qq_46506007的博客
04-17 2511
Java正则表达式 正则表达式越到后面学习的好难啊！ 0、正则表达式中，字符分为 普通字符和元字符 1、普通字符： 大小写字母，数字 ，下划线，部分特殊符号， 非西文字符等 主要元字符：\ { } * ? + ( ) [ ] - | ^ $ Pattern类和Matcher类 没有构造方法，只能用普通方法创建对象。 Patternpattern=Pattern.compile(正则表达式); 、 创建pattern对象。然后 ...
javacc
liu_jin_hui的博客
11-11 677
JavaCC官方入门指南-概述 解析器生成器之 JavaCC（1）： JavaCC 准备篇 编译原理之Javacc使用 JavaCC是一个词法分析器和语法分析器的生成工具。其主要功能是通过用户给定的文法规则，生成一个纯Java语言编写的语法分析器。用户输入一段测试字符串，该分析器就能判断该字符串是否满足该文法的规则。检测合法性的同时，也可以生成该字符串的语法分析树。另外，该工具还能根据用户定义的模板文件生成对应的描述该语言的文档。 通常所说的javacc指的是javacc.jar这个jar包，jar包中包含
JavaCC中扩展的正规表达式
思念
10-31 1177
From 《Compiler Construction Using Java ，JavaCC ，Yacc》　　 在JavaCC使用的扩展正规表达式中，字母表中的符号或这些符号的串括在双引号中。如表示 “b”或者“c”的表达式是 　　 "b"|"c"其中竖线表示联合操作 而"b|c"只表示一个串”b|c”，因为竖线被包含在引号中，不属于联合操作。 　　 　　在javacc扩展正规表达式中，可以
JAVA使用正则表达式匹配字符串中的token（其他字段）对应的值
weixin_46716951的博客
04-14 488
这段代码首先定义了一个字符串str，包含了需要处理的字符串。然后使用正则表达式"token=(\d+)“，其中”\d+"表示匹配任意数字，来匹配字符串中的token对应的值。接着使用Matcher对象的find()方法查找匹配项，如果找到了就使用group()方法获取匹配的值。最后将结果输出到控制台。根据提供的搜索结果，Token是一种服务端生成的字符串，用于客户端进行请求的令牌。如果需要从字符串中准确匹配出token对应的值，可以使用Java正则表达式来实现。
python re 正则表达式提取token
人生苦短，何妨一试
06-19 1114
python re 正则表达式提取token
javaCC Eclipse插件
11-09
javacc插件，推荐使用.exe安装版的那一个。配合eclipse使用 安装版只用点击程序依次运行便可以啦，超级好用啦。
javacc语法分析.zip
01-16
javacc语法分析
JavaCC语法文件中文版 V2.0_静水71
11-03
JavaCC 语法文件 中文版本 翻译的英文，并做了整理，形成了标题，便于查看。 只用于学习交流，如需发布，请不要修改其内容。谢谢！
Generating Parsers with JavaCC-Centennial
09-09
Tom Copeland - Generating Parsers with JavaCC-Centennial Books (2009)
JAVACC使用总结（二）：词法TOKEN
qq_15089775的博客
01-23 2733
词法类型 哪些要定义成TOKEN? 样例
正则表达式提取器获得token
weixin_30412167的博客
03-30 1311
转载于:https://www.cnblogs.com/Jollyxi/p/8675493.html
jemter之正则表达式提取
路人甲~的博客
09-30 7684
通常在使用jemter进行接口测试时，上一个接口的返回值传给下个接口，这时就需要用到正则表达式提取相关参数并进行参数化，话不多说，开始吧 例如：App端需要进行实现一个点赞的操作 1.点赞首先需要登录，用户名密码登录，登录后生成用户token 2.我们需要将响应结果中的token正则提取成为一个参数，传给下一个接口，具体 3.在登录的请求下添
JavaCC简单语法
Hyvi的专栏
09-26 297
options { LOOKAHEAD = 1; CHOICE_AMBIGUITY_CHECK = 2; OTHER_AMBIGUITY_CHECK = 1; STATIC = true; DEBUG_PARSER = false; DEBUG_LOOKAHEAD = false; DEBUG_TOKEN_MANAGER = false; ERR...
javaCC教程-1、简单语法解析案例
Brave Soul Blog
04-03 3298
javaCC入门教程-1、匹配括号 1、配置javacc环境变量 将javacc的路径添加到系统变量Path，D:\java源码包\javacc\javacc-5.0\bin 测试javacc命令 cmd模式下j输入javacc测试 Simple1.jj 文件内容如下： options { LOOKAHEAD = 1; CHOICE_AMBIGUITY_CHECK = 2; O...
JAVACC使用总结（一）：基础入门
qq_15089775的博客
01-05 1万+
JAVACC使用总结（一）：基础入门 安装及环境设置 JAVACC版的Hello word
Java 正则表达式
热门推荐
学而不厌 诲人不倦
08-31 3万+
介绍 前段时间使用Java的正则表达式做一些字符串匹配的任务，现将学到的正则表达式的知识整理成文。 Java中Spring.class涉及到正则表达式。如Spring.split()， matches()，replaceAll()等方法。 Java中更一般使用正则表达式的方式是利用Pattern.class和Matcher.class，所在package为java.util.regex J...
编写 javacc 算术表达式计算 的jj文件
最新发布
06-03
下面是一个简单的JAVACC算术表达式计算的jj文件示例： ``` options { STATIC = true; // 生成静态方法 } // 定义运算符优先级 precedence left PLUS, MINUS; precedence left TIMES, DIVIDE; // 定义运算表达式文法 void expression() : {} { term() ( <PLUS> term() { // 加法运算 int value = pop() + pop(); push(value); } | <MINUS> term() { // 减法运算 int value = -pop() + pop(); push(value); } )* } void term() : {} { factor() ( <TIMES> factor() { // 乘法运算 int value = pop() * pop(); push(value); } | <DIVIDE> factor() { // 除法运算 int divisor = pop(); int value = pop() / divisor; push(value); } )* } void factor() : {} { ( <INTEGER> { // 数字 push(Integer.parseInt(token.image)); } | <LPAREN> expression() <RPAREN> { // 括号表达式 } ) } // 定义堆栈 int[] stack = new int[100]; int top = -1; // 压栈 void push(int value) { top++; stack[top] = value; } // 出栈 int pop() { int value = stack[top]; top--; return value; } ``` 该示例中，通过定义expression()、term()和factor()三个方法来实现算术表达式的计算，同时定义了堆栈和相关的push()、pop()方法来存储和获取计算结果。在运行该程序时，可以通过调用expression()方法来计算给定的算术表达式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值