JavaCC

http://www.cnblogs.com/forfuture1978/archive/2010/05/08/1730200.html

一、Lucene的查询语法

Lucene所支持的查询语法可见http://lucene.apache.org/java/3_0_1/queryparsersyntax.html

(1) 语法关键字

+ - && || ! ( ) { } [ ] ^ " ~ * ? : \

如果所要查询的查询词中本身包含关键字，则需要用\进行转义

(2) 查询词(Term)

Lucene支持两种查询词，一种是单一查询词，如"hello"，一种是词组(phrase)，如"hello world"。

(3) 查询域(Field)

在查询语句中，可以指定从哪个域中寻找查询词，如果不指定，则从默认域中查找。

查询域和查询词之间用:分隔，如title:"Do it right"。

:仅对紧跟其后的查询词起作用，如果title:Do it right，则仅表示在title中查询Do，而it right要在默认域中查询。

(4) 通配符查询(Wildcard)

支持两种通配符：?表示一个字符，*表示多个字符。

通配符可以出现在查询词的中间或者末尾，如te?t，test*，te*t，但决不能出现在开始，如*test，?test。

(5) 模糊查询(Fuzzy)

模糊查询的算法是基于Levenshtein Distance，也即当两个词的差别小于某个比例的时候，就算匹配，如roam~0.8，即表示差别小于0.2，相似度大于0.8才算匹配。

(6) 临近查询(Proximity)

在词组后面跟随~10，表示词组中的多个词之间的距离之和不超过10，则满足查询。

所谓词之间的距离，即查询词组中词为满足和目标词组相同的最小移动次数。

如索引中有词组"apple boy cat"。

如果查询词为"apple boy cat"~0，则匹配。

如果查询词为"boy apple cat"~2，距离设为2方能匹配，设为1则不能匹配。

(0)

boy

apple

cat

(1)

boy

apple

cat

(2)

apple

boy

cat

如果查询词为"cat boy apple"~4，距离设为4方能匹配。

(0)	cat	boy	apple
(1)		cat boy	apple
(2)		boy	cat apple
(3)		boy apple	cat
(4)	apple	boy	cat

(7) 区间查询(Range)

区间查询包含两种，一种是包含边界，用[A TO B]指定，一种是不包含边界，用{A TO B}指定。

如date:[20020101 TO 20030101]，当然区间查询不仅仅用于时间，如title:{Aida TO Carmen}

(8) 增加一个查询词的权重(Boost)

可以在查询词后面加^N来设定此查询词的权重，默认是1，如果N大于1，则说明此查询词更重要，如果N小于1，则说明此查询词更不重要。

如jakarta^4 apache，"jakarta apache"^4 "Apache Lucene"

(9) 布尔操作符

布尔操作符包括连接符，如AND，OR，和修饰符，如NOT，+，-。

默认状态下，空格被认为是OR的关系，QueryParser.setDefaultOperator(Operator.AND)设置为空格为AND。

+表示一个查询语句是必须满足的(required)，NOT和-表示一个查询语句是不能满足的(prohibited)。

(10) 组合

可以用括号，将查询语句进行组合，从而设定优先级。

如(jakarta OR apache) AND website

Lucene的查询语法是由QueryParser来进行解析，从而生成查询对象的。

通过编译原理我们知道，解析一个语法表达式，需要经过词法分析和语法分析的过程，也即需要词法分析器和语法分析器。

QueryParser是通过JavaCC来生成词法分析器和语法分析器的。

二、JavaCC介绍

本节例子基本出于JavaCC tutorial的文章，http://www.engr.mun.ca/~theo/JavaCC-Tutorial/

JavaCC是一个词法分析器和语法分析器的生成器。

所谓词法分析器就是将一系列字符分成一个个的Token，并标记Token的分类。

例如，对于下面的C语言程序：

int main() {

return 0 ;

}

将被分成以下的Token:

“int”, “ ”, “main”, “(”, “)”,

“”,“{”, “\n”, “\t”, “return”

“”,“0”,“”,“;”,“\n”,

“}”, “\n”, “”

标记了Token的类型后如下：

KWINT, SPACE, ID, OPAR, CPAR,

SPACE, OBRACE, SPACE, SPACE, KWRETURN,

SPACE, OCTALCONST, SPACE, SEMICOLON, SPACE,

CBRACE, SPACE, EOF

EOF表示文件的结束。

词法分析器工作过程如图所示：

此一系列Token将被传给语法分析器(当然并不是所有的Token都会传给语法分析器，本例中SPACE就例外)，从而形成一棵语法分析树来表示程序的结构。

JavaCC本身既不是一个词法分析器，也不是一个语法分析器，而是根据指定的规则生成两者的生成器。

2.1、第一个实例——正整数相加

下面我们来看第一个例子，即能够解析正整数相加的表达式，例如99+42+0+15。

(1) 生成一个adder.jj文件

此文件中写入的即生成词法分析器和语法分析器的规则。

(2) 设定选项，并声明类

/* adder.jj Adding up numbers */

options {

STATIC = false ;

}

PARSER_BEGIN(Adder)

class Adder {

static void main( String[] args ) throws ParseException, TokenMgrError {

Adder parser = new Adder( System.in ) ;

parser.Start() ;

}

PARSER_END(Adder)

STATIC选项默认是true，设为false，使得生成的函数不是static的。

PARSER_BEGIN和PARSER_END之间的java代码部分，此部分不需要通过JavaCC根据规则生成java代码，而是直接拷贝到生成的java代码中的。

(3) 声明一个词法分析器

SKIP : { " " }

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

TOKEN : { < PLUS : "+" > }

TOKEN : { < NUMBER : (["0"-"9"])+ > }

第一二行表示空格和回车换行是不会传给语法分析器的。

第三行声明了一个Token，名称为PLUS，符号为“+”。

第四行声明了一个Token，名称为NUMBER，符号位一个或多个0-9的数的组合。

如果词法分析器分析的表达式如下：

“123 + 456\n”，则分析为NUMBER, PLUS, NUMBER, EOF
“123 - 456\n”，则报TokenMgrError，因为“-”不是一个有效的Token.
“123 ++ 456\n”，则分析为NUMBER, PLUS, PLUS, NUMBER, EOF，词法分析正确，后面的语法分析将会错误。

(4) 声明一个语法分析器

void Start() :

{}

{

(

<PLUS>

<EOF>

}

语法分析器使用BNF表达式。

上述声明将生成start函数，称为Adder类的一个成员函数

语法分析器要求输入的语句必须以NUMBER开始，以EOF结尾，中间是零到多个PLUS和NUMBER的组合。

(5) 用javacc编译adder.jj来生成语法分析器和词法分析器

最后生成的adder.jj如下：

options
{
static = false;
}

PARSER_BEGIN(Adder)
package org.apache.javacc;

public class Adder
{
public static void main(String args []) throws ParseException
{
Adder parser = new Adder(System.in);
parser.start();
}
}
PARSER_END(Adder)

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

TOKEN : /* OPERATORS */
{
< PLUS : "+" >
}

TOKEN :
{
< NUMBER : ([ "0"-"9" ])+ >
}

void start() :
{}
{
<NUMBER>
(
<PLUS>
<NUMBER>
)*
}

用JavaCC编译adder.jj生成如下文件：

Adder.java：语法分析器。其中的main函数是完全从adder.jj中拷贝的，而start函数是被javacc由adder.jj描述的规则生成的。
AdderConstants.java：一些常量，如PLUS, NUMBER, EOF等。
AdderTokenManager.java：词法分析器。
ParseException.java：用于在语法分析错误的时候抛出。
SimpleCharStream.java：用于将一系列字符串传入词法分析器。
Token.java：代表词法分析后的一个个Token。Token对象有一个整型域kind，来表示此Token的类型(PLUS, NUMBER, EOF)，有一个String类型的域image，来表示此Token的值。
TokenMgrError.java：用于在词法分析错误的时候抛出。

下面我们对adder.jj生成的start函数进行分析：

final public void start() throws ParseException {

//从词法分析器取得下一个Token，而且要求必须是NUMBER类型，否则抛出异常。

//此步要求表达式第一个出现的字符必须是NUMBER。

jj_consume_token(NUMBER);

label_1:

while (true) {

//jj_ntk()是取得下一个Token的类型，如果是PLUS，则继续进行，如果是EOF则退出循环。

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case PLUS:

;

break;

default:

jj_la1[0] = jj_gen;

break label_1;

}

//要求下一个PLUS字符，再下一个是一个NUMBER，如此下去。

jj_consume_token(PLUS);

jj_consume_token(NUMBER);

}

(6) 运行Adder.java

如果输入“123+456”则不报任何错误。

如果输入“123++456”则报如下异常：

Exception in thread "main" org.apache.javacc.ParseException: Encountered " "+" "+ "" at line 1, column 5.
Was expecting:
    <NUMBER> ...
    at org.apache.javacc.Adder.generateParseException(Adder.java:185)
    at org.apache.javacc.Adder.jj_consume_token(Adder.java:123)
    at org.apache.javacc.Adder.start(Adder.java:24)
    at org.apache.javacc.Adder.main(Adder.java:8)

如果输入“123-456”则报如下异常：

Exception in thread "main" org.apache.javacc.TokenMgrError: Lexical error at line 1, column 4. Encountered: "-" (45), after : ""
    at org.apache.javacc.AdderTokenManager.getNextToken(AdderTokenManager.java:262)
    at org.apache.javacc.Adder.jj_ntk(Adder.java:148)
    at org.apache.javacc.Adder.start(Adder.java:15)
    at org.apache.javacc.Adder.main(Adder.java:8)

2.2、扩展语法分析器

在上面的例子中的start函数中，我们仅仅通过语法分析器来判断输入的语句是否正确。

我们可以扩展BNF表达式，加入Java代码，使得经过语法分析后，得到我们想要的结果或者对象。

我们将start函数改写为：

int start() throws NumberFormatException :

{

//start函数中有三个变量

Token t ;

int i ;

int value ;

}

{

//首先要求表达式的第一个一定是一个NUMBER，并把其值付给t

t= <NUMBER>

//将t的值取出来，解析为整型，放入变量i中

{ i = Integer.parseInt( t.image ) ; }

//最后的结果value设为i

{ value = i ; }

//紧接着应该是零个或者多个PLUS和NUMBER的组合

(

<PLUS>

//每出现一个NUMBER，都将其付给t，并将t的值解析为整型，付给i

t= <NUMBER>

{ i = Integer.parseInt( t.image ) ; }

//将i加到value上

{ value += i ; }

//最后的value就是表达式的和

{ return value ; }

}

生成的start函数如下：

final public int start() throws ParseException, NumberFormatException {

Token t;

int i;

int value;

t = jj_consume_token(NUMBER);

i = Integer.parseInt(t.image);

value = i;

label_1: while (true) {

switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {

case PLUS:

;

break;

default:

jj_la1[0] = jj_gen;

break label_1;

}

jj_consume_token(PLUS);

t = jj_consume_token(NUMBER);

i = Integer.parseInt(t.image);

value += i;

}

{

if (true)

return value;

}

throw new Error("Missing return statement in function");

}

从上面的例子，我们发现，把一个NUMBER取出，并解析为整型这一步是可以共用的，所以可以抽象为一个函数：

int start() throws NumberFormatException :

{

int i;

int value ;

}

{

value = getNextNumberValue()

(

<PLUS>

i = getNextNumberValue()

{ value += i ; }

{ return value ; }

}

int getNextNumberValue() throws NumberFormatException :

{

Token t ;

}

{

t=<NUMBER>

{ return Integer.parseInt( t.image ) ; }

}

生成的函数如下：

final public int start() throws ParseException, NumberFormatException {

int i;

int value;

value = getNextNumberValue();

label_1: while (true) {

switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {

case PLUS:

;

break;

default:

jj_la1[0] = jj_gen;

break label_1;

}

jj_consume_token(PLUS);

i = getNextNumberValue();

value += i;

}

{

if (true)

return value;

}

throw new Error("Missing return statement in function");

}

final public int getNextNumberValue() throws ParseException, NumberFormatException {

Token t;

t = jj_consume_token(NUMBER);

{

if (true)

return Integer.parseInt(t.image);

}

throw new Error("Missing return statement in function");

}

2.3、第二个实例：计算器

(1) 生成一个calculator.jj文件

用于写入生成计算器词法分析器和语法分析器的规则。

(2) 设定选项，并声明类

options {

STATIC = false ;

}

PARSER_BEGIN(Calculator)

import java.io.PrintStream ;

class Calculator {

static void main( String[] args ) throws ParseException, TokenMgrError, NumberFormatException {

Calculator parser = new Calculator( System.in ) ;

parser.Start( System.out ) ;

}

double previousValue = 0.0 ;

}

PARSER_END(Calculator)

previousValue用来记录上一次计算的结果。

(3) 声明一个词法分析器

SKIP : { " " }

TOKEN : { < EOL:"\n" | "\r" | "\r\n" > }

TOKEN : { < PLUS : "+" > }

我们想要支持小数，则有四种情况：没有小数，小数点在中间，小数点在前面，小数点在后面。则语法规则如下：

TOKEN { < NUMBER : (["0"-"9"])+ | (["0"-"9"])+ "." (["0"-"9"])+ | (["0"-"9"])+ "." | "." (["0"-"9"])+ > }

由于同一个表达式["0"-"9"]使用了多次，因而我们可以定义变量，如下：

TOKEN : { < NUMBER : <DIGITS> | <DIGITS> "." <DIGITS> | <DIGITS> "." | "." <DIGITS>> }

TOKEN : { < #DIGITS : (["0"-"9"])+ > }

(4) 声明一个语法分析器

我们想做的计算器包含多行，每行都是一个四则运算表达式，语法规则如下：

Start -> (Expression EOL)* EOF

void Start(PrintStream printStream) throws NumberFormatException :

{}

{

(

previousValue = Expression()

<EOL>

{ printStream.println( previousValue ) ; }

<EOF>

}

每一行的四则运算表达式如果只包含加法，则语法规则如下：

Expression -> Primary (PLUS Primary)*

double Expression() throws NumberFormatException :

{

double i ;

double value ;

}

{

value = Primary()

(

<PLUS>

i= Primary()

{ value += i ; }

{ return value ; }

}

其中Primary()得到一个数的值：

double Primary() throws NumberFormatException :

{

Token t ;

}

{

t= <NUMBER>

{ return Double.parseDouble( t.image ) ; }

}

(5) 扩展词法分析器和语法分析器

如果我们想支持减法，则需要在词法分析器中添加：

TOKEN : { < MINUS : "-" > }

语法分析器应该变为：

Expression -> Primary (PLUS Primary | MINUS Primary)*

double Expression() throws NumberFormatException :

{

double i ;

double value ;

}

{

value = Primary()

(

<PLUS>

i = Primary()

{ value += i ; }

<MINUS>

i = Primary()

{ value -= i ; }

{ return value ; }

}

如果我们想添加乘法和除法，则在词法分析器中应该加入：

TOKEN : { < TIMES : "*" > }

TOKEN : { < DIVIDE : "/" > }

对于加减乘除混合运算，则应该考虑优先级，乘除的优先级高于加减，应该先做乘除，再做加减：

Expression -> Term (PLUSTerm | MINUSTerm)*

Term -> Primary (TIMES Primary | DIVIDE Primary)*

double Expression() throws NumberFormatException :

{

double i ;

double value ;

}

{

value = Term()

(

<PLUS>

i= Term()

{ value += i ; }

<MINUS>

i= Term()

{ value -= i ; }

{ return value ; }

}

double Term() throws NumberFormatException :

{

double i ;

double value ;

}

{

value = Primary()

(

<TIMES>

i = Primary()

{ value *= i ; }

i = Primary()

{ value /= i ; }

{ return value ; }

}

下面我们要开始支持括号，负号，以及取得上一行四则运算表达式的值。

对于词法分析器，我们添加如下Token：

TOKEN : { < OPEN PAR : "(" > }

TOKEN : { < CLOSE PAR : ")" > }

TOKEN : { < PREVIOUS : "$" > }

对于语法分析器，对于最基本的表达式，有四种情况：

其可以是一个NUMBER，也可以是上一行四则运算表达式的值PREVIOUS，也可以是被括号括起来的一个子语法表达式，也可以是取负的一个基本语法表达式。

Primary –> NUMBER | PREVIOUS | OPEN_PAR Expression CLOSE_PAR | MINUS Primary

double Primary() throws NumberFormatException :

{

Token t ;

double d ;

}

{

t=<NUMBER>

{ return Double.parseDouble( t.image ) ; }

{ return previousValue ; }

<OPEN PAR> d=Expression() <CLOSE PAR>

{ return d ; }

<MINUS> d=Primary()

{ return -d ; }

}

(6) 用javacc编译calculator.jj来生成语法分析器和词法分析器

最后生成的calculator.jj如下：

options
{
static = false;
}

PARSER_BEGIN(Calculator)
package org.apache.javacc.calculater;
import java.io.PrintStream ;
class Calculator {
    static void main( String[] args ) throws ParseException, TokenMgrError, NumberFormatException {
      Calculator parser = new Calculator( System.in ) ;
      parser.start( System.out ) ;
    }
    double previousValue = 0.0 ;
}
PARSER_END(Calculator)

SKIP : { " " }
TOKEN : { < EOL: "\n" | "\r" | "\r\n" > }
TOKEN : { < PLUS : "+" > }
TOKEN : { < MINUS : "-" > }
TOKEN : { < TIMES : "*" > }
TOKEN : { < DIVIDE : "/" > }
TOKEN : { < NUMBER : <DIGITS> | <DIGITS> "." <DIGITS> | <DIGITS> "." | "." <DIGITS>> }
TOKEN : { < #DIGITS : (["0"-"9"])+ > }
TOKEN : { < OPEN_PAR : "(" > }
TOKEN : { < CLOSE_PAR : ")" > }
TOKEN : { < PREVIOUS : "$" > }

void start(PrintStream printStream) throws NumberFormatException :
{}
{
(
previousValue = Expression()
{ printStream.println( previousValue ) ; }
)*
}

double Expression() throws NumberFormatException :
{
double i ;
double value ;
}
{
value = Term()
(
    <PLUS>
    i= Term()
    { value += i ; }
    |
    <MINUS>
    i= Term()
    { value -= i ; }
)*
{ return value ; }
}

double Term() throws NumberFormatException :
{
double i ;
double value ;
}
{
value = Primary()
(
    <TIMES>
    i = Primary()
    { value *= i ; }
    |
    <DIVIDE>
    i = Primary()
    { value /= i ; }
)*
{ return value ; }
}

double Primary() throws NumberFormatException :
{
Token t ;
double d ;
}
{
t=<NUMBER>
{ return Double.parseDouble( t.image ) ; }
|
<PREVIOUS>
{ return previousValue ; }
|
<OPEN_PAR> d=Expression() <CLOSE_PAR>
{ return d ; }
|
<MINUS> d=Primary()
{ return -d ; }
}

生成的start函数如下：

final public void start(PrintStream printStream) throws ParseException, NumberFormatException {

label_1:

while (true) {

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case MINUS:

case NUMBER:

case OPEN_PAR:

case PREVIOUS:

;

break;

default:

jj_la1[0] = jj_gen;

break label_1;

}

previousValue = Expression();

printStream.println( previousValue ) ;

}

final public double Expression() throws ParseException, NumberFormatException {

double i ;

double value ;

value = Term();

label_2:

while (true) {

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case PLUS:

case MINUS:

;

break;

default:

jj_la1[1] = jj_gen;

break label_2;

}

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case PLUS:

jj_consume_token(PLUS);

i = Term();

value += i ;

break;

case MINUS:

jj_consume_token(MINUS);

i = Term();

value -= i ;

break;

default:

jj_la1[2] = jj_gen;

jj_consume_token(-1);

throw new ParseException();

}

{if (true) return value ;}

throw new Error("Missing return statement in function");

}

final public double Term() throws ParseException, NumberFormatException {

double i ;

double value ;

value = Primary();

label_3:

while (true) {

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case TIMES:

case DIVIDE:

;

break;

default:

jj_la1[3] = jj_gen;

break label_3;

}

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case TIMES:

jj_consume_token(TIMES);

i = Primary();

value *= i ;

break;

case DIVIDE:

jj_consume_token(DIVIDE);

i = Primary();

value /= i ;

break;

default:

jj_la1[4] = jj_gen;

jj_consume_token(-1);

throw new ParseException();

}

{if (true) return value ;}

throw new Error("Missing return statement in function");

}

final public double Primary() throws ParseException, NumberFormatException {

Token t ;

double d ;

switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

case NUMBER:

t = jj_consume_token(NUMBER);

{if (true) return Double.parseDouble( t.image ) ;}

break;

case PREVIOUS:

jj_consume_token(PREVIOUS);

{if (true) return previousValue ;}

break;

case OPEN_PAR:

jj_consume_token(OPEN_PAR);

d = Expression();

jj_consume_token(CLOSE_PAR);

{if (true) return d ;}

break;

case MINUS:

jj_consume_token(MINUS);

d = Primary();

{if (true) return -d ;}

break;

default:

jj_la1[5] = jj_gen;

jj_consume_token(-1);

throw new ParseException();

}

throw new Error("Missing return statement in function");

}

----------------------------------------------------------------------------------------------------------

Lucene学习总结之一：全文检索的基本原理

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623594.html

Lucene学习总结之二：Lucene的总体架构

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623596.html

Lucene学习总结之三：Lucene的索引文件格式(1)

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623597.html

Lucene学习总结之三：Lucene的索引文件格式(2)

http://www.cnblogs.com/forfuture1978/archive/2009/12/14/1623599.html

Lucene学习总结之三：Lucene的索引文件格式(3)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661436.html

Lucene学习总结之四：Lucene索引过程分析(1)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661439.html

Lucene学习总结之四：Lucene索引过程分析(2)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661440.html

Lucene学习总结之四：Lucene索引过程分析(3)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661441.html

Lucene学习总结之四：Lucene索引过程分析(4)

http://www.cnblogs.com/forfuture1978/archive/2010/02/02/1661442.html

Lucene学习总结之五：Lucene段合并(merge)过程分析

http://www.cnblogs.com/forfuture1978/archive/2010/03/06/1679501.html

Lucene学习总结之六：Lucene打分公式的数学推导

http://www.cnblogs.com/forfuture1978/archive/2010/03/07/1680007.html

Lucene学习总结之七：Lucene搜索过程解析(1)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704242.html

Lucene学习总结之七：Lucene搜索过程解析(2)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704245.html

Lucene学习总结之七：Lucene搜索过程解析(3)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704250.html

Lucene学习总结之七：Lucene搜索过程解析(4)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704254.html

Lucene学习总结之七：Lucene搜索过程解析(5)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704258.html

Lucene学习总结之七：Lucene搜索过程解析(6)

http://www.cnblogs.com/forfuture1978/archive/2010/04/04/1704263.html

posted on 2015-04-21 18:51 SIMONE 阅读(311) 评论(0) 编辑收藏

常用链接

留言簿(46)

随笔分类(476)

随笔档案(495)

最新随笔

搜索

积分与排名

最新评论

阅读排行榜

评论排行榜

一、Lucene的查询语法

(1) 语法关键字

(2) 查询词(Term)

(3) 查询域(Field)

(4) 通配符查询(Wildcard)

(5) 模糊查询(Fuzzy)

(6) 临近查询(Proximity)

(7) 区间查询(Range)

(8) 增加一个查询词的权重(Boost)

(9) 布尔操作符

(10) 组合

二、JavaCC介绍

2.1、第一个实例——正整数相加

(1) 生成一个adder.jj文件

(2) 设定选项，并声明类

(3) 声明一个词法分析器

(4) 声明一个语法分析器

(5) 用javacc编译adder.jj来生成语法分析器和词法分析器

(6) 运行Adder.java

2.2、扩展语法分析器

2.3、第二个实例：计算器

(1) 生成一个calculator.jj文件

(2) 设定选项，并声明类

(3) 声明一个词法分析器

(4) 声明一个语法分析器

(5) 扩展词法分析器和语法分析器

(6) 用javacc编译calculator.jj来生成语法分析器和词法分析器


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻 Chat2DB C++博客博问管理