javacc 如何配置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(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 "  "abbba "" at line 1, column 1.
//Was expecting one of:
//     
//     ...
//	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)

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

void test():
{
  Token t = null;
}
{
 (
   t = < S>
   {
   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那么肯定会报错报告类型
//不同字符匹配在开始第一个字母怎么去区分于其他字符很重要
/**********************/


/**********************/
//就如:
//
// 

//需要在生产表达式中用的才搞成全局的不然都要局部的
//< 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_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_CHAR>)* >
}

/** 范围查询中间连接符定义*/
TOKEN :
{
  < RANGE_TO :
    (
      (" ")*"to"(" ")*
    | (" ")*"TO"(" ")*
    | (" ")*"To"(" ")*
    | (" ")*"tO"(" ")*
    | (" ")*"~"(" ")*
    | (" ")*"-"(" ")*
    ) >
}
//TOKEN:{
//  < CMPLEX_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不同大小写的形势*/
   |
   |<#_CMP:(" ")*(<_W >|<_F >|(<_W ><_F >))< NUMBER>(" ")* > 
   |(" ")*>
   |(|< 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={cpl.append(t1);complex_term();}
      |{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();})
      |{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 = )
        < RANGE_TO >
    (t2= )
    (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 = |symbole = ) 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>
    {
    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>
  {
    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();
  }
}

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