javacc学习

为什么要研究这些，除了个人兴趣之外，还有可以了解语言是怎样解析字符串生成逻辑代码。

他的应用性也是非常之广，如人工智能方面，把复杂的逻辑抽象成简单的文法，不懂编程的人都可以使用

说到人工智能，数据库SQL查询也算是，大家可能会觉得，这也算人工智能？

是的，如果程序员完全用过程方式去写逻辑查询的话，会疯掉，像淘宝级别的数据，假设每天产生一个数据库

如何多天查询？群集数据库如何分布式统计？

还有大型游戏的AI，一个怪物攻击过程有:检查状态->扫描目标->选择技能->计算伤害->保存数据->next ai

如果写一个怪物还好点，但一个游戏不会只有一个怪物吧，成千上万怎么办？

我在这里保证，大家都能学会。哈哈

先来介绍下 bnf 文法，内容我就不复杂了

一些概念简单说下

1.词法元素

2.词法标识

一组元素里包含多个标识，请看具体写法

TOKEN:{

<PLUS:"+">

|<NUMBER:(["0"-"9"])+>

|<NUM: <NUMBER> | (<NUMBER>.<NUMBER> )* >

}

翻译

词法元素:{

<词法标识1:"+">

|<词法标识2:(["0"-"9"])+>

|<词法标识3:<词法标识2>+>

}

多个标识用 | 关联起来，标识也可以嵌套也一标识

标识对应匹配的词，可以用正则书写.总的过讲比正则简单多了，但前提是你会正则

解析过程原理:

1.先定义各种词法元素 可按操作符，变量关键词，逻辑关键词等草划分词法元素

2.所谓的语法表达式 是结构节点编程 如果你精通结构编程，这点难不到你

如元素与元素相似的就用兄弟节点,上下属关系相似性不大就用父子节点

3.提取出来词法标识 相应的值，做逻辑处理。这时候提取出来了，想干嘛就干嘛

下面来自牛人总结一幅图

Javacc 简介

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

这里列出我收集的资料

//基础

//http://forfuture1978.iteye.com/blog/661678

//http://cs.lmu.edu/~ray/notes/javacc/

//sql

//http://www.codeproject.com/Articles/35748/An-Introduction-to-JavaCC

//http://www.codeproject.com/Articles/50377/Create-Your-Own-Programming-Language

//base

//http://ramkulkarni.com/blog/handling-some-of-the-warnings-and-errors-generated-by-javacc/

Jdk 默认是没有的，要下载安装

执行命令

java -cp E:\javacc-6.0\bin\lib\javacc.jar javacc exp.jj

Javacc 语法简介

他可以跟 bnf 混编写如

int expr()  :{

int reslt = 0;

int i = 0;

Token t=null;

}

{

t =  <NUM>

{

  result =Integer.parseInt(t.image)

return result;

}

}

翻译 混编

int expr()  :{ java 局部变量，声明在这里 可以直接访问 bnf  }

{

t =  <NUM> // 将 匹配的单词赋值给 t

{

//{} JAVA代码必须写在 {}里

//javacc Token 对象有个重要属性 image 是匹配出来的值

  result =Integer.parseInt(t.image)

return result;

}

}

一个完整的+-/*运算例子

分析:

逻辑优先级是 () 号，然后是 */ ,再到+-

options 

{ 

  static = false; 

}

PARSER_BEGIN(Calculator) 

package com.jj;

import java.io.PrintStream ; 

  public class Calculator { 

    public 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 ; }

}

如果还觉得复杂，你可以跳过，我还是有信心保证你也会写的

下面直接josql 分析

其中核心代码

void _Query(Query q):

{ 

List cols = null;

List fromItems = null;

List joins = null;

Expression where = null;

List orderBys = null;

List groupOrderBys = null;

List groupBys = null;

Expression having = null;

Limit limit = null;

        Limit grpLimit = null;

        Expression from = null;

        Map execute = null;

        boolean distinct = false;

}

{

    <K_SELECT>  [ LOOKAHEAD(2) <K_DISTINCT> { q.setWantDistinctResults (true); } ]

    cols = SelectItemsList(q)

    from = From() 

    [ where = WhereClause() ]

    [ LOOKAHEAD(2) groupBys = GroupBys() ]

    [ having = Having() ]

    [ LOOKAHEAD(GroupOrderBys()) groupOrderBys = GroupOrderBys() ]

    [ orderBys = OrderBys() ]

    [ LOOKAHEAD(GroupLimit()) grpLimit = GroupLimit() ]

    [ limit = Limit() ]

    [ execute = ExecuteOn() ]

    { 

      // We set all the values since they are all dependent on the class 

      // being available.

      q.setFrom (from); 

      q.setColumns (cols);

      q.setWhere (where);

      q.setHaving (having);

      q.setGroupByOrderColumns (groupOrderBys);

      q.setOrderByColumns (orderBys);

      q.setGroupByColumns (groupBys);

      q.setGroupByLimit (grpLimit);

      q.setLimit (limit);

      q.setExecuteOnFunctions (execute);

    }

}

无非是提取出相应的参数，保存起来做处理而已，然提取过程可能会很复杂但基本是是结构节点编程

下面我来总结一下:

1.以sql 为例语法格式无非是 a指令 a参数 b指令 b参数 N... N个拼起来

2.提取出来的参数再做处理过程

我们来做个抽象演变

a指令 a参数 b指令 b参数 N...

直接抛开解析语法过程

Query( a参数,  b参数 , c参数,n...)

这种书写也可以达到工人智能，但不太友好

再来一层抽象

{

a指令 : a参数,

b指令 : b参数,

n....

}

无错，就是JSON

大多数人对JSON 的认识还停留在数据方面

我总结下JSON 几大特精:

1.数据

2.类

3.结构

4.协议

5.文法 (从上面演变)

JS 特性我认为就两大，1是JSON 2.是回调。我个人是非常喜欢JSON的