精华内容
下载资源
问答
  • HQChart使用教程14-分析家语法执行器

    千次阅读 2019-06-26 14:05:35
    分析家语法执行器分析家语法执行器为什么要开发一个分析家语法执行器Demo页面部分代码执行结果格式HQChart代码地址 分析家语法执行器 HQChart 内置一个分析家语法的执行器, 把分析家脚本通过词法,语法分析构建一个...

    分析家语法执行器

    HQChart 内置一个分析家语法的执行器, 把分析家脚本通过词法,语法分析构建一个抽象语法树(AST), 执行器通过AST执行, 最后获得数据。 (具体细节我就不多讲了,很枯燥,有兴趣的可以看下“编译原理”, 都是一样的标准化流程)

    为什么要开发一个分析家语法执行器

    目前市面上的H5K线图指标,无非就是前端计算或后台计算。

    1. 前端计算:通过基础的K线数据(开,高,低,收,成交金额,成交量,外加一些财务数据),使用js 来计算出对应的指标数据,
      好处呢: 降低指标计算对服务器的压力,因为都在本地计算了。
      弊端呢
    • 新加指标需要前端开发人员把指标翻译成js语言, 并且需要发布新的前端页面
    • 对前端开发人员开发水准要求比较高,执行器里面需要很多金融的计算函数如协方差,beta系数等都需要js来完成。
    • 指标基本就不能保密, 都是前端js,懂点js的人都可以查看你的代码
    1. 后端计算: 也是通过基础的K线数据, 单可以使用任何服务器开发语言来计算指标数据(c++, .net , nodejs. py …)
      好处呢
    • 可选择的开发人员很多,高手比较好招,不需要局限与js人员, 毕竟js的人大部分都是从事UI方面开发,让他们做算法基本会把他们逼疯的。
    • 增加指标只需要后台升级。
    • 指标计算过程前端是看不到的, 保密性比较好。
      坏处呢: 每次都需要从服务器请求指标,在交易时间段, 对服务器压力比较打。 就比方说1个K线图, 你设置30s更新一次K线数据, 那用户多了对后台服务器的压力和流量都是很大的考验

    基于上面前后端优劣, 我们把分析家语法使用js重新实现了一遍。我们为了让脚本能同时在前端和后台都可以执行, 我们使用js来现实,后台直接可以使用nodejs, 调用我们的分析家执行器js代码。 这样一套代码前后台都通过。 nodejs性能基本和py差不多, 如果你要追求速度,那只能是用c/c++去实现了。

    Demo页面部分代码

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    <html xmlns="http://www.w3.org/1999/xhtml">  
    <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />  
    <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no" />
    <title>指标执行测试</title>   
    </head>  
    <body>
    
        <script src="content/js/jquery.min.js"></script>
        <script src="../jscommon/umychart.network.js"></script>
        <script src="../jscommon/umychart.js"></script>
        <script src="../jscommon/umychart.complier.js"></script>
        
        <script>
    
            $(function ()
            {
                var obj=  //分析家脚本,
                {
                    Name:'测试', ID:'11111', 
                    Args:[ { Name:'M1', Value:5}, { Name:'M2', Value:10 }, { Name:'M3', Value:20} ],
                    Script: //脚本
                        'MA1:MA(CLOSE,M1);\n\
                        MA2:MA(CLOSE,M2);\n\
                        MA3:MA(CLOSE,M3);',
                    ErrorCallback:ExecuteError,   //执行错误回调
                    FinishCallback:ExecuteFinish, //计算结果回调
                };
    
                var indexConsole=new ScriptIndexConsole(obj);	//创建一个分析家的语法执行器
    
                var stockObj=  //指标执行的股票
                {
                    HQDataType:HQ_DATA_TYPE.KLINE_ID, //K线数据
                    Stock: {Symbol:'600000.sh'},      //股票代码
                    Request: { MaxDataCount: 500, MaxMinuteDayCount:5 }, //计算数据个数
                    Period:0 ,  //周期 0 日线 1 周线 2 月线 3 年线 
                    Right:1    //复权 0 不复权 1 前复权 2 后复权
                };
    
                indexConsole.ExecuteScript(stockObj);	//执行指标
            })
    
            function ExecuteError(error)
            {
                console.log('[ExecuteError] Error: ',error)
            }
    
            function ExecuteFinish(data, jsExectute)	//接收执行完成以后的数据
            {
                console.log('[ExecuteFinish] data, jsExectute ',data, jsExectute)
            }
            
        </script>  
    </body>  
    </html>
    

    nodejs也是一样的方法调用。导出 ScriptIndexConsole,HQ_DATA_TYPE。

    执行结果格式

    返回结果如下图:在这里插入图片描述
    Date 数据的日期数组
    Out 脚本执行结果返回,一个变量一个数组, 数据对应的日期就是Date的数组
    Stock 执行的股票名称 代码
    JSExecute 执行器实例

    如果你已经开发了一个h5k线图,那可以直接内嵌我们的分析家语法执行器,把执行器计算好的指标显示在你的h5K线图上。
    如果你需要策略选股,或策略参数调优都可以使用我们的执行器,使用nodejs并行批量的执行一个板块的股票。

    如果还有问题可以加交流QQ群: 950092318

    HQChart代码地址

    地址:https://github.com/jones2000/HQChart

    展开全文
  • 分析家语法执行器 HQChart 内置一个分析家语法的执行器, 把分析家脚本通过词法,语法分析构建一个抽象语法树(AST), 执行器通过AST执行, 最后获得数据。我把这套体系又移植到了python上, 目前只支持python3版本 ...

    分析家语法执行器

    HQChart 内置一个分析家语法的执行器, 把分析家脚本通过词法,语法分析构建一个抽象语法树(AST), 执行器通过AST执行, 最后获得数据。我把这套体系又移植到了python上, 目前只支持python3版本
    python执行器地址: \umychart_python\ 这个目录下

    Demo部分代码

    我们要计算一个MA(5) MA(10) MA(15)

    import sys
    from umychart_complier_jscomplier import ScriptIndexConsole, ScriptIndexItem, SymbolOption, RequestOption, HQ_DATA_TYPE, ArgumentItem
    
    def Test_ScriptIndexConsole():
        # 创建脚本, 及参数
        scpritInfo=ScriptIndexItem(name='测试MA脚本', id=888888,
            script='MA1:MA(CLOSE,M1);\n'    # 指标脚本代码
                'MA2:MA(CLOSE,M2);\n'
                'MA3:MA(CLOSE,M3);',
            args=[ ArgumentItem(name='M1', value=5), ArgumentItem(name='M2', value=10), ArgumentItem(name='M3', value=20) ] # 脚本参数
            )
    
        indexConsole = ScriptIndexConsole(scpritInfo)
    
        option = SymbolOption(
            symbol='000001.sz', # 计算的股票
            right=1, # 复权 0 不复权 1 前复权 2 后复权
            period=0 # 周期 0=日线 1=周线 2=月线 3=年线 4=1分钟 5=5分钟 6=15分钟 7=30分钟 8=60分钟
            )
         #执行指标脚本   
        result=indexConsole.ExecuteScript(option)
    
        if not result.Error :
            print('run successfully.')
            
    Test_ScriptIndexConsole()
    

    这样3个MA的指标就计算完成。

    返回数据格式

    在这里插入图片描述
    Date:[] 日期数组 和输出变量的参数数组一一对应
    Time:[] 如果是分钟K 线指标这个就是对应的分钟
    Error: 错误信息,如果执行错误 这里会有错误信息
    OutVar:输出变量, 一个变量一个数组,如果是画图函数 Draw会保存画图的信息
    Stock: 股票信息 Name:股票名称 Symbol: 股票代码

    如果还有问题可以加交流QQ群: 950092318

    HQChart代码地址

    地址:https://github.com/jones2000/HQChart

    展开全文
  • 语法分析:自下而上分析

    千次阅读 2016-11-30 18:35:29
    自下而上分析法就是从输入串开始,逐步进行“归约”,直至归约到文法的开始符号;或者说,从语法树的末端开始,步步向上“归约”,直到根结。

    概述

    介绍自下而上语法分析方法。所谓自下而上分析法就是从输入串开始,逐步进行“归约”,直至归约到文法的开始符号;或者说,从语法树的末端开始,步步向上“归约”,直到根结。

    自下而上分析基本问题

    归约

    我们所讨论的自下而上分析法是一种“移进-归约”法。这种方法的大意是,用一个寄存符号的先进后出栈,把输入符号一个一个地移进到栈里,当栈顶形成某个产生式的一个候选式时,即把栈顶的这一部分替换成(归约为)该产生式的左部符号。

    首先考虑下面的例子:
    假定文法G为

       (1) S→aAcBe
       (2) A→b
       (3) A→Ab
       (4) B→d     <1>
    

    我们希望把输入串abbcde归约到S。每实现一步归约都是把栈顶的一串符号用某个产生式的左部符号来代替。后面我们权且把栈顶上的这样一串符号称为“可归约串” ,存在种种不同的方法刻画“可归约串”。对这个概念的不同定义形成了不同的自下而上分析法。在算符优先分析中,用“最左素短语”来刻画“可归约串”,在“规范归约”分析中,则用“句柄”来刻画“可归约串”。

    自下而上分析的中心问题是,怎样判断栈顶的符号串的可归约性,以及,如何归约。这是算符优先分析LR分析将讨论的问题。各种不同的自下而上分析法的一个共同特点是,边输入单词符号(移进符号栈),边归约。也就是在从左到右移进输入串的过程中,一旦发现栈顶呈现可归约串就立即进行归约。这个过程对于编译实现来说是一个十分自然的过程。

    规范归约简介

    令G是一个文法,S是文法的开始符号,假定abd是文法G的一个句型,如果有

    saAdA+b

    则称b是句型abd相对于非终结符A的短语。特别是,如果有

    AÞb

    则称b是句型abd相对于规则A→b的直接短语, 一个句型的最左直接短语称为该句型的句柄。

    作为“短语”的两个条件均是不可缺少的。仅仅有Ab,未必意味着b就是句型abd的一个短语。因为,还需有SaAd这一条件。

    稍为精确的一点说,假定a是文法G的一个句子,我们称序列

    an,an1,an2,.....,a1,a0

    是a的一个规范归约,如果此序列满足:

    1. an=a
    2. a0为文法的开始符,即a0=S
    3. 对任何i,0<ifn,ai1是从ai经把句柄替换为相应产生式的左部符号而得到的。

    容易看到,规范归约是关于a的一个最右推导的逆过程。因此,规范归约也称最左归约。

    在形式语言中,最右推导常被称为规范推导。由规范推导所得的句型称为规范句型。如果文法G是无二义的,那么,规范推导(最右推导)的逆过程必是规范归约(最左归约)。

    请注意句柄的“最左”特征,这一点对于移进-归约来说是重要的。因为,句柄的“最左”性和符号栈的栈顶两者是相关的。对于规范句型来说,句柄的后面不会出现非终结符号(即,句柄的后面只能出现终结符)。基于这一点,我们可用句柄来刻画移进-归约过程的“可归约串”。因此,规范归约的实质是,在移进过程中,当发现栈顶呈现句柄时就用相应产生式的左部符号进行替换。

    符号栈的使用与语法树的表示

    栈是语法分析的一种基本数据结构。在解释“移进-归约”的自下而上分析过程时我们就已经提到了符号栈。一个“移进-归约”分析器使用了这样的一个符号栈和一个输入缓冲区。今后我们将用一个不属于文法符号的特殊符号‘#’作为栈底符,即在分析开始时预先把它推进栈;同时,也用这个符号作为输入串的“结束符”,即无条件地将它置在输入串之后,以示输入串的结束。

    分析开始时,栈和输入串的初始情形为:

    符号栈 输入串
    w#

    分析器的工作过程是:自左至右把输入串w的符号一一移进符号栈里,一旦发现栈顶形成一个可归约串时,就把这个串用相应的归约符号(在规范归约的情况下用相应产生规则的左部符号)代替。这种替换可能持续多次,直至栈顶不再呈现可归约串为止。然后,就继续移进符号,重复整个过程,直至最终形成如下格局:

    符号栈 输入串
    #S

    此时,栈里只含#与最终归约符S(在规范归约的情形下S为文法开始符号),而输入串w全被吸收,仅剩下结束符。这种格局表示分析成功。如果达不到这种格局,意味着输入串w(源程序)含有语法错误。

    语法分析对符号栈的使用有四类操作:“移进”、“归约”、“接受”和“出错处理”

    • “移进” 指把输入串的一个符号移进栈。
    • “归约”指发现栈顶呈可归约串,并用适当的相应符号去替换这个串(这两个问题都还没有解决)。
    • “接受”指宣布最终分析成功,这个操作可看作是“归约”的一种特殊形式。
    • “出错处理”指发现栈顶的内容与输入串相悖,分析工作无法正常进行,此时需调用出错处理程序进行诊察和校正,并对栈顶的内容和输入符号进行调整。

    对于“归约”而言请留心一个非常重要的事实,任何可归约串的出现必在栈顶,不会在栈的内部。对于规范归约而言,这个事实是明显的。由于规范归约是最右推导的逆过程,因此这种归约具有“最左”性,故可归约串必在栈顶,而不会在栈的内部。正因如此,先进后出栈在归约分析中是一种非常有用的数据结构。

    如果要实际表示一棵语法分析树的话,一般来说,使用穿线表是比较方便的。这只须对每个进栈符号配上一个指示器就可以了。

    当要从输入串移进一个符号a入栈时,我们就开辟一项代表端末结a的数据结构,让这项数据结构的地址(指示器值)连同a本身一起进栈。端末结的数据结构应包括这样一些内容:(1) 儿子个数:0;(2) 关于a自身的信息(如单词内部值,现在暂且不管)。

    当要把栈顶的n个符号,如X1X2Xn归约为A时,我们就开辟一项代表新结A的数据结构。这项数据结构应包含这样一些内容:(1) 儿子个数:n;(2) 指向儿结的n个指示器值;(3) 关于A自身的其它信息。归约时,把这项数据结构的地址连同A本身一起进栈。

    最终,当要执行“接受”操作时,我们将发现一棵用穿线表表示的语法树业已形成,代表根结的数据结构的地址和文法的开始符号(在规范归约情况下)一起留在栈中。

    用这种方法表示语法树是最直截了当的。当然,也可以用别的或许是更加高效的表示方法。

    算符优先分析

    算符优先文法及其优先表构造

    一个文法,如果它的任一产生式的右部都不含两个相继(并列)的非终结符,即不含如下形式的产生式右部:

    QR

    则我们称该文法为算符文法

    在后面的定义中,a、b代表任意终结符;P、Q、R代表任意非终结符;‘…’代表由终结符和非终结符组成的任意序列,包括空字。

    假定G是一个不含e-产生式的算符文法。对于任何一对终结符a、b,我们说:

    1. ab当且仅当文法G中含有形如PabPaQb的产生式;
    2. ab当且仅当G中含有形如PaR的产生式,而RbRQb
    3. ab当且仅当G中含有形如PRb的产生式,而RaRaQ

    如果一个算符文法G中的任何终结符对(a,b)至多只满足下述三关系之一:

    ababab

    则称G是一个算符优先文法。

    现在来研究从算符优先文法G构造优先关系表的算法。

    通过检查G的每个产生式的每个候选式,可找出所有满足ab的终结符对。为了找出所有满足关系的终结符对,我们首先需要对G的每个非终结符P构造两个集合FIRSTVTPLASTVTP

    FIRSTVTPa|PaPQaaÎVTQÎVN

    LASTVTPa|PaPaQaÎVTQÎVN

    算符优先分析算法

    所谓素短语是指这样的一个短语,它至少含有一个终结符,并且,除它自身之外不再含任何更小的素短语。所谓最左素短语是指处于句型最左边的那个素短语。如上例,P*P和i是句型P*P+i的素短语,而P*P是它的最左素短语。

    现在考虑算符优先文法,我们把句型(括在两个#之间)的一般形式写成:

    #N1a1N2a2NnanNn+1# ……………. (4)

    其中,每个ai都是终结符,Ni是可有可无的非终结符。换言之,句型中含有n个终结符,任何两个终结符之间顶多只有一个非终结符。必须记住,任何算符文法的句型都具有这种形式。我们可以证明如下定理:
    一个算符优先文法G的任何句型(4)的最左素短语是满足如下条件的最左子串NjajNiaiNi+1

    aj1aj
    ajaj+1ai1ai
    aiai+1
    根据这个定理,下面我们讨论算符优先分析算法。为了和定理的叙述相适应,我们现在仅使用一个符号栈S,既用它寄存终结符,也用它寄存非终结符。下面的分析算法是直接根据这个定理构造出来的,其中k代表符号栈S的使用深度。

    优先函数

    在实际实现算符优先分析算法时,一般不用表5.1这样的优先表,而是用两个优先函数f和g。我们把每个终结符q与两个自然数fqgq相对应,使得

    • q1q2fq1<gq2
    • q1q2fq1=gq2 …….. (5)
    • q1q2fq1>gq2

    函数f称为入栈优先函数,g称为比较优先函数。使用优先函数有两方面的优点:便于作比较运算,并且节省存储空间,因为优先关系表占用的存储量比较大。其缺点是,原先不存在优先关系的两个终结符,由于与自然数相对应,变成可比较的了。因而,可能会掩盖输入串的某些错误。但是,我们可以通过检查栈顶符号q和输入符号a的具体内容来发现那些原先不可比较的情形。

    如果优先函数存在,那么,从优先表构造优先函数的一个简单方法是:

    1. 对于每个终结符a包括 令其对应两个符号faga,画一张以所有符号faga为结点的方向图,如果ab,那么,就从fa画一箭弧至gb;如果a⋖≖b,就画一条从gbfa的箭弧。
    2. 对每个结点都赋予一个数,此数等于从该结点出发所能到达结点(包括出发结点自身在内)的个数。赋给fa的数作为f(a),赋给gb的数作为g(b)。
    3. 检查所构造出来的函数f和g,看它们同原来的关系表是否有矛盾。如果没有矛盾,则f和g就是所要的优先函数。如果有矛盾,那么,就不存在优先函数。

    现在必须证明:若a≖b,则f(a)=g(b);若a⋖b,则f(a)< g(b);若a⋗b,则f(a)> g(b)。第一个关系可从函数的构造直接获得。因为,若a≖b,则既有从fa到gb的弧,又有从gb到fa的弧。所以,fa和gb所能到达的结是全同的。至于a⋗b和a⋖b的情形,只须证明其一。如果a⋗b,则有从fa到gb的弧。也就是,gb能到达的任何结fa也能到达。因此,f(a)³ g(b)。我们所需证明的是,在这种情况下,f(a)=g(b)不应成立。我们将指出,如果f(a)=g(b),则根本不存在优先函数。假若f(a)=g(b),那么必有

              a⋗b, a1⋖≖b, a1⋗≖b1,…am⋗≖bm, a⋖≖bm
    

    因为对任何优先函数都必须满足(5.5) 所规定的条件,而上面的关系恰恰表明,对任何优先函数f和g来说,必定有

    f(a)> g(b)³ f(a1)³ g(b1)³ … ³ f(am)³ g(bm)³ f(a)

    从而导致f(a)> f(a),产生矛盾。因此,不存在优先函数f和g。

    算符优先分析中的出错处理

    使用算符优先分析法时,可在两种情况下,发现语法错误:

    1. 若在栈顶终结符号与下一输入符号之间不存在任何优先关系;

    2. 若找到某一“句柄”(此处“句柄”指素短语),但不存在任一产生式,其右部为此“句柄”。

    针对上述情况,处理错误的子程序也可分成几类。首先,我们考虑处理类似第2种情况错误的子程序。当发现这种情况时,就应该打印错误信息。子程序要确定该“句柄”与哪个产生式的右部最相似。例如,假定从栈中确定的“句柄”是abc,可是,没有一个产生式,其右部包含a,b,c在一起。此时,可考虑是否删除a,b,c中的一个。例如,假若有一产生式,其右部为aAcB,则可给出错误信息:“非法b”;若另有一产生式,其右部为abdc,则可给出错误信息:“缺少d”。

    LR分析法

    LR分析器

    规范归约(最左归约—最右推导的逆过程)的关键问题是寻找句柄。在一般的“移进-归约”过程中,当一串貌似句柄的符号串呈现于栈顶时,我们有什么方法可以确定它是否为相对于某一产生式的句柄呢?LR方法的基本思想是,在规范归约过程中,一方面记住已移进和归约出的整个符号串,即记住“历史”,另一方面根据所用的产生式推测未来可能碰到的输入符号,即对未来进行“展望”。当一串貌似句柄的符号串呈现于分析栈的顶端时,我们希望能够根据所记载的“历史”和“展望”以及“现实”的输入符号等三方面的材料,来确定栈顶的符号串是否构成相对某一产生式的句柄。

    LR分析法的这种基本思想是很符合哲理的。因而可以想象,这种分析法也必定是非常通用的。正因如此,实现起来也就非常困难。作为归约过程的“历史”材料的积累虽不困难(实际上,这些材料都保存在分析栈中),但是,“展望”材料的汇集却是一件很不容易的事情。这种困难不是理论上的,而是实际实现上的。因为,根据历史推测未来,即使是推测未来的一个符号,也常常存在着非常多的不同可能性。因此,当把“历史”和“展望”材料综合在一起时,复杂性就大大增加。如果简化对“展望”资料的要求,我们就可能获得实际可行的分析算法。

    后面所讨论的LR方法都是带有一定限制的。

    一个LR分析器实质上是一个带先进后出存储器(栈)的确定有限状态自动机。我们将把“历史”和“展望”材料综合地抽象成某些“状态”。分析栈(先进后出存储器)用来存放状态。栈里的每个状态概括了从分析开始直到某一归约阶段的全部“历史”和“展望”资料。任何时候,栈顶的状态都代表了整个的历史和已推测出的展望。因此,在任何时候都可从栈顶状态得知你所想了解的一切,而绝对没有必要从底而上翻阅整个栈。LR分析器的每一步工作都是由栈顶状态和现行输入符号所唯一决定的。为了有助于明确归约手续,我们把已归约出的文法符号串也同时放在栈里(显然它们是多余的,因为它们已被概括在“状态”里了)。于是,我们可以把栈的结构看成是:

    栈的每一项内容包括状态s和文法符号X两部分。(s0,#)为分析开始前预先放到栈里的初始状态和句子括号。栈顶状态为sm,符号串X1X2…Xm是至今已移进归约出的部分。

    LR分析器的核心部分是一张分析表。这张分析表包括两部分,一是“动作”(ACTION)表,另一是“状态转换”(GOTO)表。它们都是二维数组。ACTION[s, a]规定了当状态s面临输入符号a时应采取什么动作。GOTO[s,X]规定了状态s面对文法符号X(终结符或非终结符)时下一状态是什么。显然,GOTO[s,X]定义了一个以文法符号为字母表的DFA。

    每一项ACTION[s,a]所规定的动作不外是下述四种可能之一:

    1. 移进 把(s,a)的下一状态s¢=GOTO[s,a]和输入符号a推进栈,下一输入符号变成现行输入符号。

    2. 归约 指用某一产生式A→b进行归约。假若b的长度为r,归约的动作是A,去除栈顶的r个项,使状态sm-r变成栈顶状态,然后把(sm-r,A)的下一状态s¢=GOTO[sm-r,A]和文法符号A推进栈。归约动作不改变现行输入符号。执行归约动作意味着b(=Xm-r+1…Xm)已呈现于栈顶而且是一个相对于A的句柄。

    3. 接受 宣布分析成功,停止分析器的工作。

    4. 报错 发现源程序含有错误,调用出错处理程序。

    LR分析器的总控程序本身的工作是非常简单的。它的任何一步只需按栈顶状态s和现行输入符号a执行ACTION[s,a]所规定的动作。不管什么分析表,总控程序都是一样地工作。

    一个LR分析器的工作过程可看成是栈里的状态序列、已归约串和输入串所构成的三元式的变化过程。分析开始时的初始三元式为:

    s0, #, a1a2an#)

    其中s0为分析器的初态;#为句子的左括号;a1a2an 为输入串,其后的#为结束符(句子右括号)。分析过程每步的结果可表示为:
    s0s1sm, #X1X2Xm,aiai+1an#)

    分析器的下一步动作是由栈顶状态sm和现行输入符号ai所唯一决定的。即,执行ACTION[sm,ai]所规定的动作。经执行每种可能的动作之后,三元式的变化情形是:
    1. 若ACTION[sm,ai]为移进,且s=GOTO[sm,ai],则三元式变成:
    s0s1sms, #X1X2Xmai,ai+1an#)

    2. 若ACTION[sm,ai]=Ab,则按产生式Ab进行归约。此时三元式变为:
    s0s1smrs, # X1XmrA,aiai+1an #)

    此处s=GOTO[smr,A]rb的长度,bXmr+1Xm
    3. 若ACTION[sm,ai]为“接受”,则三元式不再变化,变化过程终止,宣布分析成功。
    4. 若ACTION[sm,ai]为“报错”,则三元式的变化过程终止,报告错误。

    一个LR分析器的工作过程就是一步一步地变换三元式,直至执行“接受”或“报错”为止。

    对于一个LR分析器来说,栈顶状态提供了所需的一切“历史”和“展望”信息。请注意一个非常重要的事实:如果仅由栈的内容和现实的输入符号就可以识别一个句柄,那么,就可以用一个有限自动机自底向上扫描栈的内容和检查现行输入符号来确定呈现于栈顶的句柄是什么(如果形成一个句柄时)。实际上,LR分析器就是这样的一个有限自动机。只是,因栈顶的状态已概括了整个栈的内容,因此,无需扫描整个栈。栈顶状态就好象已代替我们进行了这种扫描。

    LR文法

    我们主要关心的问题是,如何从文法构造LR分析表。对于一个文法,如果能够构造一张分析表,使得它的每个入口均是唯一确定的,则我们将把这个文法称为LR文法。并非所有上下文无关文法都是LR文法。但对于多数程序语言来说,一般都可用LR文法描述。直观上说,对于一个LR文法,当分析器对输入串进行自左至右扫描时,一旦句柄呈现于栈顶,就能及时对它实行归约。

    一个LR分析器有时需要“展望”和实际检查未来的k个输入符号才能决定应采取什么样的“移进-归约”决策。一般而言,一个文法,如果能用一个每步顶多向前检查k个输入符号的LR分析器进行分析,则这个文法就称为LR(k)文法。但对多数的程序语言来说,k=0或1就足够了。因此,我们只考虑k£1的情形。

    注意,LR方法关于识别产生式右部的条件远不象预测法那样严峻。预测法要求每个非终结符的所有候选的首符均不同,预测分析程序认为,一旦看到首符之后就看准了该用哪一个产生式进行推导。但LR分析程序只有在看到整个右部所推导的东西之后才认为是看准了归约方向。因此,LR方法比预测法应该更加一般化。

    LR(0)项目集族和LR(0)分析表的构造

    对于一个文法G,我们可以构造一个有限自动机,它能识别G的所有活前缀。在这个基础上,我们将讨论如何把这种自动机转变成LR分析表。

    对于一个文法G,我们首先要构造一个NFA,它能识别G的所有活前缀。这个NFA的每个状态是下面定义的一个“项目”。文法G每一个产生式的右部添加一个圆点称为G的一个LR0项目(简称项目)。例如,产生式AXYZ对应有四个项目:
    AXYZ
    AXYZ
    AXYZ
    AXYZ

    但是,产生式Ae只对应一个项目A。在计算机中,每个项目可用一对整数表示,第一个整数代表产生式编号,第二个整数指出圆点的位置。

    直观上说,一个项目指明了在分析过程的某时刻我们看到产生式多大一部分。例如,上面四项的第一个项目意味着,我们希望能从后面输入串中看到可以从XYZ推出的符号串。第二个项目意味着,我们已经从输入串中看到能从X推出的符号串,我们希望能进一步看到可以从YZ推出的符号串。

    我们可以使用这些项目状态构造一个NFA,用来识别这个文法的所有活前缀。这个文法的开始符号S¢仅在第一个产生式的左部出现。使用这个事实,我们规定项目1为NFA的唯一初态。任何状态(项目)均认为是NFA的终态(活前缀识别态)。如果状态i和j出自同一产生式,而且状态j的圆点只落后于状态i的圆点一个位置,如状态i为

    XX1Xi1XiXn

    而状态j为
    XX1XiXi+1Xn

    那么,就从状态i画一条标志为Xi的弧到状态j。假若状态i的圆点之后的那个符号为非终结符,如iXaAbA为非终结符,那么,就从状态i画e弧到所有Ag状态(即,所有那些圆点出现在最左边的A的项目)。

    子集方法,我们能够把识别活前缀的NFA确定化,使之成为一个以项目集合为状态的DFA,这个DFA就是建立LR分析算法的基础。

    构成识别一个文法活前缀的DFA的项目集(状态)的全体称为这个文法的LR(0)项目集规范族。这个规范族提供了建立一类LR(0)和SLR(简单LR)分析器的基础。

    为了便于叙述,我们用一些专门术语来称呼不同的项目。凡圆点在最右端的项目,如A→a·,称为一个“归约项目”。对文法的开始符号S¢的归约项目,如S¢→a·,称为“接受”项目。显然,“接受”项目是一种特殊的归约项目。形如A→a·ab的项目,其中a为终结符,称为“移进”项目。形如A→a·Bb的项目,其中B为非终结符,称为“待约”项目。

    LR(0)项目集规范族的构造

    下面所引进的eCLOSURE(闭包)的办法来构造一个文法G的LR(0)项目集规范族。

    为了使“接受”状态易于识别,我们总把文法G进行拓广。假定文法G是一个以S为开始符号的文法,我们构造一个G¢,它包含了整个G,但它引进了一个不出现在G中的非终结符S¢,并加进一个新产生式S¢S,而这个S¢G¢开始符号。那么,我们称G¢是G的拓广文法。这样,便会有一个仅含项目S¢→S的状态,这就是唯一的“接受”态。

    假定I是文法G¢的任一项目集,定义和构造I的闭包CLOSUREI的办法是:

    1. I的任何项目都属于CLOSUREI
    2. AaBb属于CLOSUREI,那么,对任何关于B的产生式Bg4B→·gCLOSURE(I)$;
    3. 重复执行上述两步骤直至CLOSUREI不再增大为止。

    在构造CLOSUREI时,请注意一个重要的事实,那就是,对任何非终结符B,若某个圆点在左边的项目B→·g进入到CLOSURE(I),则B的所有其它圆点在左边的项目B→·b也将进入同一个CLOSURE集。因此,在某种情况下,并不需要真正列出CLOSURE集里的所有项目B→·g,而只须列出非终结符B就可以了。

    函数GO是一个状态转换函数。GOIX的第一个变元I是一个项目集,第二个变元X是一个文法符号。函数值GOIX定义为:

    GOIXCLOSUREJ

    其中:JAaXb|AaXbI

    直观上说,若I是对某个活前缀g有效的项目集,那么,GO(I,X)便是对gX有效的项目集。通过函数CLOSURE和GO很容易构造一个文法G的拓广文法G¢的LR(0)项目集规范族。构造算法是:

    PROCEDURE  ITEMSETSG¢);
    BEGIN
             C:={CLOSURE({S¢®·S})};
             REPEAT
                       FOR  C中的每个项目集I和G¢的每个符号X  DO
                                IF GO(I,X)非空且不属于C   THEN
                                   把GO(I,X)放入C族中
             UNTIL C   不再增大
    END

    这个算法的工作结果C就是文法G¢的LR(0)项目集规范族。

    有效项目

    我们希望从识别文法的活前缀的DFA建立LR分析器(带栈的确定有限状态自动机)。因此,需要研究这个DFA的每个项目集(状态)中的项目的不同作用。

    我们说项目Ab1b2对活前缀ab1是有效的,其条件是存在规范推导S¢aAwab1b2w。一般而言,同一项目可能对好几个活前缀都是有效的(当一个项目出现在好几个不同的集合中时便是这种情形)。若归约项目A→b1·对活前缀ab1是有效的,则它告诉我们应把符号串b1归约为A,即把活前缀ab1变成aA。若移进项目A→b1·b2对活前缀ab1是有效的,则它告诉我们,句柄尚未形成,因此,下一步动作应是移进。但是,可能存在这样的情形,对同一活前缀,存在若干项目对它都是有效的。而且它们告诉我们应做的事情各不相同,互相冲突。这种冲突通过向前多看几个输入符号,或许能够获得解决。我们在下一节将讨论这种情形,当然,对于非LR文法,这种冲突有些是绝对无法解决的,不论超前多看几个输入符号也无济于事。

    对于每个活前缀,我们可以构造它的有效项目集。实际上,一个活前缀g的有效项目集正是从上述的DFA的初态出发,经读出g后而到达的那个项目集(状态)。换言之,在任何时候,分析栈中的活前缀X1X2…Xm的有效项目集正是栈顶状态Sm所代表的那个集合。这是LR分析理论的一条基本定理。实际上,栈顶的项目集(状态)体现了栈里的一切有用信息—历史。

    LR(0)分析表的构造

    假若一个文法G的拓广文法G¢的活前缀识别自动机中的每个状态(项目集)不存在下述情况:1) 既含移进项目又含归约项目,或者2) 含有多个归约项目,则称G是一个LR(0)文法。换言之,LR(0)文法规范族的每个项目集不包含任何冲突项目。

    对于LR(0)文法,我们可直接从它的项目集规范族C和活前缀识别自动机的状态转换函数GO构造出LR分析表。下面是构造LR(0)分析表的算法。

    假定CI0,I1,,In。前面,我们已习惯用数码表示状态,因此,令每个项目集Ik的下标k作为分析器的状态。特别是,令那个包含项目S¢S的集合Ik的下标k为分析器的初态。分析表的ACTION子表和GOTO子表可按如下方法构造:

    1. 若项目Aaab属于IkGOIk,aIja为终结符,则置ACTION[k,a]为“把(j,a)移进栈”,简记为“sj”。
    2. 若项目Aa属于Ik,那么,对任何终结符a(或结束符#),置ACTION[k,a]为“用产生式Aa进行归约”,简记为“rj”(假定产生式Aa是文法G¢的第j个产生式)。
    3. 若项目S¢S属于Ik,则置ACTION[k,#]为“接受”,简记为“acc”。
    4. GOIk,AIjA为非终结符,则置GOTO[k,A]=j
    5. 分析表中凡不能用规则1至4填入信息的空白格均置上“报错标志”。

    由于假定LR0文法规范族的每个项目集不含冲突项目,因此,按上法构造的分析表的每个入口都是唯一的(即,不含多重定义)。我们称如此构造的分析表是一张LR0表。使用LR0表的分析器叫做一个LR0分析器。

    SLR分析表的构造

    上面所说的LR(0)文法是一类非常简单的文法。这种文法的活前缀识别自动机的每一个状态(项目集)都不含冲突性的项目。但是,即使是定义算术表达式这样的简单文法也不是LR(0)的。因此,本节我们将要研究一种有点简单“展望”材料的LR分析法,即SLR法。

    我们将看到,许多冲突性的动作都可能通过考察有关非终结符的FOLLOW集而获解决。例如,假定一个LR(0)规范族中含有如下的一个项目集(状态)I,

    I={X→a·bb,
     Aa·,
     B→a·}

    其中,第一个项目是移进项目,第二、三项目是归约项目。这三个项目告诉我们应做的动作各不相同,互相冲突。第一个项目告诉我们应该把下一个输入符号b(如果是b)移进。第二个项目告诉我们应把栈顶的a归约为A;第三个项目则说应把a归约为B。解决冲突的一种简单办法是,分析所有含A或B的句型,考察句型中可能直接跟在A或B之后的终结符,也就是说,考察集合FOLLOW(A)和FOLLOW(B),如果这两个集合不相交,而且都不包含b,那么,当状态I面临任何输入符号a时,我们就可以采取如下的“移进-归约”决策:

    1. a=b,则移进;
    2. aÎFOLLOWA,则用产生式Aa进行归约;
    3. aÎFOLLOWB,则用产生式Ba进行归约;
    4. 此外,报错。

    一般而言,假定LR0规范族的一个项目集I中含有m个移进目;
    A1aa1b1A2aa2b2,…,Amaambm
    同时含有n个归约项目:B1aB2a,…,Bna
    如果集合{a1am}FOLLOWB1FOLLOWBn两两不相交(包括不得有两个FOLLOW集合有#),则隐含在I中的动作冲突可通过检查现行输入符号a属于上述n+1个集合中的哪个集合而获得解决。这就是:

    1. 若a是某个ai,i=1,2,…,m,则移进;
    2. 若aÎFOLLOW(Bi),i=1,2,…,n,则用产生式Bi→a进行归约;
    3. 此外,报错。
      冲突性动作的这种解决办法叫做SLR(1)解决办法。

    对任给的一个文法G,我们可用如下的办法构造它的SLR(1)分析表:首先把G拓广为G¢,对G¢构造LR(0)项目集规范族C和活前缀识别自动机的状态转换函数GO。使用C和GO,然后再按下面的算法构造G¢的SLR分析表。

    假定C={I0,I1,…,In},令每个项目集Ik的下标k为分析器的一个状态,因此,G¢的SLR分析表含有状态0,1,…,n。令那个含有项目S¢→·S的Ik的下标为初态。函数ACTION和GOTO可按如下方法构造:

    1. 若项目A→·aab属于Ik且GO(Ik,a)=Ij,a为终结符,则置ACTION[k,a]为“把状态j和符号a移进栈”,简记为“sj”;
    2. 若项目A→a·属于Ik,那么,对任何终结符a,aÎFOLLOW(A),置ACTION[k,a]为“用产生式A→a进行归约”,简记为“rj”;其中,假定A®a为文法G¢的第j个产生式;
    3. 若项目S¢→S·属于Ik,则置ACTION[k,#]为“接受”,简记为“acc”;
    4. 若GO(Ik,A)=Ij,A为非终结符,则置GOTO[k,A]=j;
    5. 分析表中凡不能用规则1至4填入信息的空白格均置上“出错标志”。

    按上述算法构造的含有ACTION和GOTO两部分的分析表,如果每个入口不含多重定义,则称它为文法G的一张SLR表。具有SLR表的文法G称为一个SLR(1)文法。数字1的意思是,在分析过程中顶多只要向前看一个符号。使用SLR表的分析器叫做一个SLR分析器。

    若按上述算法构造的分析表存在多重定义的入口(即含有动作冲突),则说明文法G不是SLR(1)的。在这种情况下,不能用上述算法构造分析器。

    每个SLR(1)文法都是无二义的。但也存在许多无二义文法不是SLR(1)的。

    规范LR分析表的构造

    在SLR方法中,若项目集Ik含有A→a·,那么,在状态k时,只要所面临的输入符号aÎFOLLOW(A),就确定采取“用A→a归约”的动作。但是,在某种情况下,当状态k呈现于栈顶时,栈里的符号串所构成的活前缀ba未必允许把a归约为A,因为可能没有一个规范句型含有前缀bAa。因此,在这种情况下,用A→a进行归约未必有效。

    可以设想让每个状态含有更多的“展望”信息,这些信息将有助于克服动作冲突和排除那种用A→a所进行的无效归约。我们可以设想,必要时,对状态进行分裂,使得LR分析器的每个状态能够确切地指出,当a后跟哪些终结符时才容许把a归约为A。

    我们需要重新定义项目,使得每个项目都附带有k个终结符。现在每个项目的一般形式是[Aab,a1a2ak],此处,Aab是一个LR(0)项目,每一个a都是终结符。这样的一个项目称为一个LR(k)项目。项目中的 a1a2ak 称为它的向前搜索符串(或展望串)。向前搜索符串仅对归约项目[Aaa1a2ak]有意义。对于任何移进或待约项目[Aab,a1a2ak],b¹e,搜索符串a1a2ak 没有作用。归约项目[Aa,a1a2ak]意味着:当它所属的状态呈现在栈顶且后续的k个输入符号为a1a2ak 时,才可以把栈顶上的a归约为A。我们只对k£1的情形感兴趣,因为,对多数程序语言的语法来说,向前搜索(展望)一个符号就多半可以确定“移进”或“归约”。

    形式上我们说一个LR1项目[Aab,a]对于活前缀g是有效的,如果存在规范推导

    SdAwdabw

    其中,1)gda2)a是w的第一个符号,或者a为#而w为e。
    构造有效的LR(1)项目集族的办法本质上和构造LR(0)项目集规范族的办法是一样的。类似地,我们也需要两个函数CLOSURE和GO。

    假定I是一个项目集,它的闭包CLOSURE(I)可按如下方式构造:
    1. I的任何项目都属于CLOSURE(I)。
    2. 若项目[A→a·Bb, a]属于CLOSURE(I),B→x是一个产生式,那么,对于FIRST(ba)中的每个终结符b,如果[B→·x, b]原来不在CLOSURE(I)中,则把它加进去。
    3. 重复执行步骤2,直至CLOSURE(I)不再增大为止。
    因为,[A→a·Bb, a]属于对活前缀g=da有效的项目集意味着存在一个规范推导

    SdAacdaBbac

    因此,若bac可推导出bw,则对于每个形如B®x的产生式,我们有SgBbwgxbw,也就是说,[B→·x, b]对g也是有效的。注意,b可能是从b推出的第一个符号,或者,若b推出e,则b就是a,把这两种可能性结合在一起,我们说bÎFIRST(ba)。
    令I是一个项目集,X是一个文法符号,函数GO(I,X)定义为:

    GOIXCLOSUREJ

    其中
    J[AaXb,a]|[AaXb,a]ÎI

    关于文法G¢的LR(1)项目集族C的构造算法是:

    BEGIN
           C:={CLOSURE({[S¢→·S,#]})};
           REPEAT
                  FOR       C中的每个项目集I和G¢的每个符号X    DO
                         IF    GO(I,X)非空且不属于C,THEN 把GO(I,X)加入C中
           UNTIL    C不再增大
    END

    现在来讨论从文法的LR(1)项目集族C构造分析表的算法。

    假定C={I0, I1,…, In},令每个Ik的下标k为分析表的状态。令那个含有[S¢→·S, #]的Ik的k为分析器的初态。动作ACTION和状态转换GOTO可构造如下:

    1. 若项目[A→a·ab, b]属于Ik且GO(Ik, a)=Ij, a为终结符,则置ACTION[k, a]为“把状态j和符号a移进栈”,简记为“sj”。
    2. 若项目[A→a·,a]属于Ik,则置ACTION[k, a]为“用产生式A→a归约”,简记为“rj”;其中假定A→a为文法G¢的第j个产生式。
    3. 若项目[S¢→S·, #]属于Ik,则置ACTION[k, #]为“接受”,简记为“acc”。
    4. 若GO(Ik,A)=Ij,则置GOTO[k, A]=j。
    5. 分析表中凡不能用规则1至4填入信息的空白栏均填上“出错标志”。

    按上述算法构造的分析表,若不存在多重定义的入口(即,动作冲突)的情形,则称它是文法G的一张规范的LR(1)分析表。使用这种分析表的分析器叫做一个规范的LR分析器。具有规范的LR(1)分析表的文法称为一个LR(1)文法。
    每个SLR(1)文法都是LR(1)文法。一个SLR(1)文法规范的LR分析器比其SLR分析器含有更多的状态。

    LALR分析表的构造

    现在来讨论构造分析表的LALR 方法。这本质上是一种折衷方法。LALR 分析表比规范LR分析表要小得多,能力也差一点。但它却能对付一些SLR所不能对付的情形,例如,文法(5.9)的情形。

    对于同一个文法,LALR 分析表和SLR分析表永远具有相同数目的状态。对于ALGOL一类语言来说,一般要用几百个状态,但若用规范LR分析表,同一类语言,却要用几千个状态。因此,用SLR或LALR要经济得多。

    我们称两个LR(1)项目集具有相同的心,如果除去搜索符之后,这两个集合是相同的。我们将试图把所有同心的LR(1)项目集合并为一。我们还将看到一个心就是一个LR(0)项目集。

    由于GO(I,X)的心仅仅依赖于I的心,因此,LR(1)项目集合并后的转换函数GO可通过GO(I,X)自身的合并而得到。即,在合并项目集时用不着同时考虑修改转换函数的问题。动作ACTION应进行修改,使得能够反映各被合并的集合的既定动作。

    假定有一个LR(1)文法,即,它的LR(1)项目集不存在动作冲突,如果我们把同心集合并为一,就可能导致存在冲突。但是这种冲突不会是“移进—归约”冲突。因为,如存在这种冲突,则意味着,面对当前的输入符号a,有一个项目[A→a·, a]要求采取归约动作,同时又有另一项目[B→b·ag, b]要求把a移进。这两个项目既然同处在合并之后的一个集合中,则意味着,在合并前,必有某个c使得[A→a·, a]和[B→b·ag, b]同处于(合并前的)某一集合中。然而,这一点又意味着,原来的LR(1)项目集就已存在着“移进—归约”冲突。故同假设不符。因此,同心集的合并不会产生新的“移进-归约”冲突。

    但是,同心集的合并有可能产生新的“归约—归约”冲突。例如,考虑文法
    (0) S¢→S
    (1) S→aAd | bBd | aBe | bAe
    (2) A→c
    (3) B→c

    这个文法只产生四个符号串:acd、bcd、ace和bce。如果我们构造这个文法的LR(1)项目集族,那么,将发现不会存在冲突性动作。因而它是一个LR(1)文法。在它的集族中,对活前缀ac有效的项目集为{[A→c·, d], [B→c·, e]},对bc有效的项目集为{[A→c·, e], [B→c·, d]}。这两个集合都不含冲突,它们是同心的。一经合并就变成:{[A→c·, d/e], [B→c·, d/e]。显然,这是一个含有“归约—归约”冲突的集合。因为,当面临e或d时,我们不知道该用A→c还是用B→c进行归约。

    下面,我们将给出构造LALR分析表算法。基本思想是,首先构造LR(1)项目集族,如果它不存在冲突,就把同心集合并在一起。若合并后的集族不存在归约-归约冲突,就按这个集族构造分析表。这个算法的主要步骤是:

    1. 构造文法G的LR(1)项目集族C={I0, I1, …, In}。
    2. 把所有的同心集合并在一起,记C¢={J0, J1, …, Jm}为合并后的新族。那个含有项目[S¢®·S, #]的Jk为分析表的初态。
    3. 从C¢构造ACTION表:
      (1) 若[A→a·ab, b]ÎIk且GO(Jk, a)=Ji,a为终结符,则置ACTION[k, a]为“sj”。
      (2) 若[A→a·,a] ÎJk,则置ACTION[k, a]为“使用A®a归约”,简记为“rj”;其中假定A→a为文法G¢的第j个产生式。
      (3) 若[S¢→S·, #]ÎJk,则置ACTION[k, #]为“接受”,简记为“acc”。
    4. GOTO表的构造:假定Jk是Ii1,Ii2,…,Iit合并后的新集。由于所有这些Ii同心,因此,GO(Ii1, X),GO(Ii2, X),…,GO(Iit, X)也具同心。记Ji为所有这些GO合并后的集。那么,就有GO(Jk, X)=Ji。于是,若GO(Jk,A)=Ji,则置GOTO[k,A]=j。
    5. 分析表中凡不能用3、4填入信息的空白格均填上“出错标志”。

    经上述步骤构造的分析表若不存在冲突,则称它为文法G的LALR分析表。存在这种分析表的文法称为一个LALR(1)文法。

    这个算法的思想虽然简单明确,但实现起来甚费时间和空间。

    二义文法的应用

    任何二义文法决不是一个LR文法,因而也不是SLR或LALR文法。这是一条定理。但是,某些二义文法是非常有用的。例如,若用下面的文法来描述含有+、*的算术表达式:

    EEE|EE|(E)|i .......<1>

    那么,只要对算符+、*赋予优先级和结合规则,这个文法是再简单不过了。这个文法与文法
    EET|T
    TTF|F ......<2>
    F(E)|i

    相比,有两个明显的好处:首先,如需要改变算符的优先级或结合规则无需去改变文法<1>自身。其次,文法<1>的分析表所包含的状态肯定比<2>所包含的状态要少得多。因为<2>中含有单非产生式(右部只含一个单一的非终结符)ETTF,这些旨在定义算符优先级和结合规则的产生式要占用不少状态和消耗不少时间。本节将讨论如何使用LR分析法的基本思想,凭借一些其它条件,来分析二义文法所定义的语言。

    LR分析中的出错处理

    在LR分析过程中,当我们处在这样一种状态下,即输入符号既不能移入栈顶,栈内元素又不能归约时,就意味着发现语法错误。发现错误后,便进入相应的出错处理子程序。处理的方法分为两类:第一类多半使用插入、删除或修改的办法。如在语句a[1,2:=3.14;中插入一个]。如果不可能使用这种办法,则采用第二类办法。第二类处理办法包括在检查到某一不合适的短语时,它不能与任一非终结符可能推导出的符号串相匹配。如语句

    if x>k+2 then go 10 else k is 2;

    由于把保留字goto误写成go,校正程序试图改成goto,但后面还有错误(将‘:=’误为‘is’),故放弃将go换为goto。校正子程序在此种情况下,将go 1跳过,作为非法语句看待。这种方法企图将含有语法错误的短语局部化。分析程序认定含有错误的符号串是由某一非终结符A所推导出的,此时该符号串的一部分已经处理,处理的结果反映在栈顶部一系列状态中,剩下的未处理符号仍在输入串中。分析程序跳过这些剩余符号,直至找到一个符号a,它能合法地跟在A的后面。同时,要把栈顶的内容逐个移去,直至找到某一状态s,该状态与A有一个对应的新状态GOTO[s,A],并将该新状态下推入栈。这样,分析程序就认为它已找到A的某个匹配并已将它局部化,然后恢复正常的分析过程。

    利用这种方法,可以以语句为单位进行处理,也可以把跳过的范围缩小。例如,若在‘if’后面的表达式中遇到某一错误,分析程序可跳至下一个输入符号‘then’而不是‘;’或‘end’。

    与算符优先分析方法比较,用LR分析方法时,设计特定的出错处理子程序比较容易,因为不会发生不正确的归约。在分析表的每一空项内,可以填入一个指示器,指向特定的出错处理子程序。第一类错误的处理一般采用插入、删除或修改的办法,但要注意,不能从栈内移去任何那种状态,它代表已成功地分析了的程序中的某一成分。

    前面讨论的只是很简单的情况。一个可投入实际运行的LR分析程序,需要考虑许多更为复杂的情形。例如,当处在某一状态下遇到各种不合法的符号时,错误诊察子程序需要向前查看几个符号,根据所查看的符号才能确定应采取哪一种处理办法。又如前已述及,分析表中有些状态在遇到不合法的输入符号时,不是立即转到错误诊察子程序,而是进行某些归约,这不仅推迟了发现错误的时间,而且往往会带来一些处理上的困难。试研究下面的一输入符号串:

    a:=b?c];

    这里以‘?’表示在b与c之间有某个错误。如果分析程序遇到‘a:=b’而不向前多看几个符号,则它就会把‘a:=b’先归约成语句,而后我们就再没有机会通过简单地插入符号‘[’进行修补了。但是,即使采用向前查看的办法,查看的符号也不能太多,否则会使分析表变得过分庞大。应该找出一种切实可行的办法,使得在确定处理出错办法时能够参考一些语义信息,以便在向前查看几个符号时,可以避免作出有时从语法上看是正确的,然而却是无意义的校正这一情况。例如,语句

    a[1,2:=3.14;

    中,标识符‘a’是一个数组标识符,这一语义信息将导致插入符号‘]’。

    典型题解

    1. 例题 什么叫句柄?什么叫素短语?(北京航空航天大学1999年硕士生入学考试)
      解答:一个句型的最左直接短语称为该句型的句柄。所谓素短语是指这样的一个短语,它至少含有一个终结符,并且,除它自身之外不再含任何更小的素短语。

    2. 例题 文法G(S):
      SbTc
      Sa
      TR
      RR/S
      RS
      符号串bR/bTc/bSc/ac是不是该文法的一个句型,请证实。若是句型,写出该句型的所有短语、素短语以及句柄。(上海交大1997年试题)
      解答: 由于有推导:
      SÞbTcÞbRcÞbR/Sc
      ÞbR/S/ScÞbR/S/S/ScÞbR/bTc/S/ScÞbR/bTc/bTc/Sc
      ÞbR/bTc/bRc/ScÞbR/bTc/bSc/ScÞbR/bTc/bSc/ac
      所以,bR/bTc/bSc/acG的一个句型。
      句型bR/bTc/bSc/ac中:
      短语:aSbScbTcR/bTcR/bTc/bScR/bTc/bSc/abR/bTc/bSc/ac
      素短语:abScbTc
      句柄:bTc

    3. 例题 给出文法G(S)
      SSaA|A
      AAbB|B
      BcSd|e
      请证实AacAbcBaAdbed是文法G的一个句型;请写出该句型的所有短语、素短语以及句柄。(上海交大2000年试题)
      解答: 由于有推导:
      SÞSaAÞAaAÞAaBÞAacSd
      ÞAacAdÞAacAbBd
      ÞAacAbBbBdÞAacAbcSdbBdÞAacAbcSaAdbBd
      ÞAacAbcAaAdbBdÞAacAbcBaAdbBdÞAacAbcBaAdbed
      所以,AacAbcBaAdbedG的一个句型。
      句型AacAbcBaAdbed中:
      短语:
      eBABaAcBaAdAbcBaAdAbcBaAdbecAbcBaAdbedAacAbcBaAdbed
      素短语:eBaA
      句柄:B

    参考文献

    1. ..1984.
    2. AlfredV.Aho,RaviSethi,JeffreyD.Ullman.Compilers:Principles,Techniques,andTools. AcldisonWesleyPublishingCompany,1986.
    3. A.V.Aho,J.D.Ullman.PrinciplesofCompilerDescign,Addison=Wesley,1977.
    4. 王兵山,吴兵,形式语言. 国防科技大学出版社,1988.
    5. A.Salomaa.FormalLanguages.AcademicPress,1975.
    6. lexyaccJohnR.Levine,TonyMason,DougBrown,,
    7. StephenC.Johnson.Yacc:YetAnotherCompilerCompiler.http://dinosaur.compilertools.net/yacc/index.html
    展开全文
  • 词法分析(Lexical analysis或Scanning)和词法分析程序(Lexical analyzer或Scanner)   词法分析阶段是编译过程的第一个阶段。这个阶段的任务是从左到右一个字符一个字符地读入源程序,即对...语法分析(Syntax

    词法分析(Lexical analysis或Scanning)和词法分析程序(Lexical analyzer或Scanner) 
      词法分析阶段是编译过程的第一个阶段。这个阶段的任务是从左到右一个字符一个字符地读入源程序,即对构成源程序的字符流进行扫描然后根据构词规则识别单词(也称单词符号或符号)。词法分析程序实现这个任务。词法分析程序可以使用lex等工具自动生成。

    语法分析(Syntax analysis或Parsing)和语法分析程序(Parser) 
      语法分析是编译过程的一个逻辑阶段。语法分析的任务是在词法分析的基础上将单词序列组合成各类语法短语,如“程序”,“语句”,“表达式”等等.语法分析程序判断源程序在结构上是否正确.源程序的结构由上下文无关文法描述.

    语义分析(Syntax analysis) 
      语义分析是编译过程的一个逻辑阶段. 语义分析的任务是对结构上正确的源程序进行上下文有关性质的审查, 进行类型审查.例如一个C程序片断:
      int arr[2],b;
      b = arr * 10; 
      源程序的结构是正确的. 
      语义分析将审查类型并报告错误:不能在表达式中使用一个数组变量,赋值语句的右端和左端的类型不匹配.

    Lex 
      一个词法分析程序的自动生成工具。它输入描述构词规则的一系列正规式,然后构建有穷自动机和这个有穷自动机的一个驱动程序,进而生成一个词法分析程序.

    Yacc 
      一个语法分析程序的自动生成工具。它接受语言的文法,构造一个LALR(1)分析程序.因为它采用语法制导翻译的思想,还可以接受用C语言描述的语义动作,从而构造一个编译程序. Yacc 是 Yet another compiler compiler的缩写.

    源语言(Source language)和源程序(Source program) 
      被编译程序翻译的程序称为源程序,书写该程序的语言称为源语言.

    目标语言(Object language or Target language)和目标程序(Object program or Target program) 
      编译程序翻译源程序而得到的结果程序称为目标程序, 书写该程序的语言称为目标语言.

    中间语言(中间表示)(Intermediate language(representation)) 
      在进行了语法分析和语义分析阶段的工作之后,有的编译程序将源程序变成一种内部表示形式,这种内部表示形式叫做中间语言或中间表示或中间代码。所谓“中间代码”是一种结构简单、含义明确的记号系统,这种记号系统复杂性介于源程序语言和机器语言之间,容易将它翻译成目标代码。另外,还可以在中间代码一级进行与机器无关的优化。

     

    文法(Grammars) 
      文法是用于描述语言的语法结构的形式规则。文法G定义为四元组(,,,)。其中为非终结符号(或语法实体,或变量)集;为终结符号集;为产生式(也称规则)的集合;产生式(规则)是形如或 a ::=b 的(a , b)有序对,其中(∪)且至少含有一个非终结符,而(∪)。,和是非空有穷集。称作识别符号或开始符号,它是一个非终结符,至少要在一条规则中作为左部出现。 
      一个文法的例子: G=(={A,R},={0,1} ,={A?0R,A?01,R?A1},=A) 
    文法分类(A hierarchy of Grammars) 
      著名语言学家Noam Chomsky定义了四类文法和四种形式语言类,文法的四种类型分别是0型、1型、2型和3型。几类文法的差别在于对产生式施加不同的限制,分别是: 
      0型文法(短语结构文法)(phrase structure grammars): 
      设G=(,,,),如果它的每个产生式是这样一种结构: (∪)  且至少含有一个非终结符,而(∪),则G是一个0型文法。 
      1型文法(上下文有关文法)(context-sensitive grammars): 
      设G=(,,,)为一文法,若中的每一个产生式均满足|,仅仅  除外,则文法G是1型或上下文有关的。 
      2型文法(上下文无关文法)(context-free grammars): 
      设G=(,,,),若P中的每一个产生式满足:是一非终结符,(∪)  则此文法称为2型的或上下文无关的。 
      3型文法(正规文法)(regular grammars): 
      设G=(,,,),若中的每一个产生式的形式都是A→aB或A→a,其中A和B都是非终结,a是终结符,则G是3型文法或正规文法。 
      0型文法产生的语言称为0型语言。 
      1型文法产生的语言称为1型语言,也称作上下文有关语言。 
      2型文法产生的语言称为2型语言,也称作上下文无关语言。 
      3型文法产生的语言称为3型语言,也称作正规语言。

    展开全文
  • 编译原理之词法分析语法分析

    千次阅读 2010-11-02 11:56:16
    词法分析(Lexical analysis或Scanning)和词法分析程序(Lexical analyzer或Scanner) 词法分析阶段是编译过程的第一个阶段。这个阶段的任务是从左到右一个字符一个字符地读入源程序,即对构成...语法分析(Syntax...
  • 什么是词法分析语法分析

    千次阅读 2011-09-08 17:55:34
    词法分析(Lexical analysis或Scanning)和词法分析程序(Lexical analyzer或Scanner)  词法分析阶段是编译过程的第一个阶段。这个阶段的任务是从左到右一个字符一个字符地读入源程序,即对构成源程序的字符流...
  • Redy语法分析--抽象语法树简介

    万次阅读 2014-07-27 12:52:23
     抽象语法树简介 (一)简介 抽象语法树(abstract syntax code,AST)是源代码的抽象语法结构的树状表示,树上...抽象语法树并不依赖于源语言的语法,也就是说语法分析阶段所采用的上下文无文文法,因为在写文
  • Java语法

    万次阅读 多人点赞 2019-08-27 16:50:13
    语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学 Peter.J.Landin(彼得·兰丁) 发明的一个术语,指在计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。语法糖...
  • 昨天去上海大学计算机中心参加PAT考试,机房使用的开发环境是vs2008不说,连自动语法分析都没打开,必须要compile以后才能找到代码中一些显然的拼写错误和笔误,非常不方便。当时也没时间了解这个功能的开启方式。...
  • Java 语法糖详解

    千次阅读 2018-02-09 00:00:00
    「文末高能」编辑 | 哈比语法语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学 Peter.J.Landin 发明的一个术语,指在计算机语言中添加的某种语法。这种语法对语言的功能并没有影响,但是更方便程序员...
  • 在前面我们介绍了Stanford ...工具以及对各种语言的支持如下表(英文和中文支持的最好),分别对应:分词,断句,定词性,词元化,分辨命名实体,语法分析,情感分析,同义词分辨等。 Annotatorarzhenfrdees...
  • 语法

    千次阅读 2012-07-05 17:02:17
    语法(Case Grammar)是美国语言学菲尔墨(C.J.Fillmore)在60代中期提出来的着重探讨句法结构与语义之间关系的一种语法理论和语义学理论。 结构主义语言学,特别是作为结构主义语言学一个分支的美国描写语言学...
  • 语法糖--这一篇全了解

    千次阅读 多人点赞 2018-08-28 09:30:19
    语法糖(Syntactic Sugar),也称糖衣语法,是由英国计算机学 Peter.J.Landin 发明的一个术语,指在计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。简而言之,语法糖让程序...
  • AST抽象语法

    千次阅读 2018-09-16 13:54:23
    抽象语法树(abstract syntax code,AST)是源代码的抽象语法结构的树状表示,树上的每个节点都表示源代码中的一种结构,这所以说是抽象的,是因为抽象语法树并不会表示出真实语法出现的每一个细节,比如说,嵌套...
  • 逻辑英语语法笔记

    万次阅读 多人点赞 2019-04-02 21:32:03
    逻辑英语语法笔记 该笔记是笔者学习钟平老师的逻辑英语英语语法的笔记,主要目的总结和复习,如需要更深入学习请到网易有道精品课里学习。 一、中英文对切公式 1、基本公式 主干相同:主谓宾位置不变 ...
  • 谈一谈JAVA里的语法糖 上周在听大牛分享JVM编译优化时,提到了在编译阶段会进行的一个步骤:解语法糖。他提出了一个问题是:JAVA里有哪些语法糖,听到这个问题,似乎很容易回答,因为我们都知道java有很多语法糖,但...
  • 语法树学习总结

    千次阅读 2016-06-29 19:01:31
    语法语法树是句子结构的图形表示,它代表了句子的推导结果,有利于理解句子语法结构的层次。简单说,语法树就是按照某一规则进行推导时所形成的树。 中文名 语法树 外文名 Parse Tree 文 法 G=(Vn,Vt,P,S) ...
  • 抽象语法

    万次阅读 2016-09-01 11:18:10
    抽象语法树(abstract syntax code,AST)是源代码的抽象语法结构的树状表示,树上的每个节点都表示源代码中的一种结构,这所以说是抽象的,是因为抽象语法树并不会表示出真实语法出现的每一个细节,比如说,嵌套...
  • Java的语法

    千次阅读 2018-08-31 19:04:48
    语法糖(Syntactic sugar),也译为糖衣语法,是由英国计算机科学彼得·约翰·兰达(Peter J. Landin)发明的一个术语,指计算机语言中添加的某种语法,这种语法对语言的功能并没有影响,但是更方便程序员使用。...
  • 目录 学Python你应该get到的三句话! 跟紧潮流不是随波逐流! 投靠大佬不是投机取巧! 赚取利益不是急功近利!...") you_dog.wang() you_dog.shen() '''继承''' '''定义并使用子类''' class Car(): """汽车之...
  • AST 抽象语法

    千次阅读 2018-10-17 00:03:52
    AST(Abstract Syntax Tree)是源代码的抽象语法结构树状表现形式,Webpack、ESLint、JSX、TypeScript 的编译和模块化规则之间的转化都是通过 AST 来实现对代码的检查、分析以及编译等操作。 JavaScript 语法的 ...
  • Python系列整体框架包括基础语法10篇、网络爬虫30篇、可视化分析10篇、机器学习20篇、大数据分析20篇、图像识别30篇、人工智能40篇、Python安全20篇、其他技巧10篇。您的关注、点赞和转发就是对秀璋最大的支持,...
  • 欢迎大家来到“Python从零到壹”,在这里我将分享...Python系列整体框架包括基础语法10篇、网络爬虫30篇、可视化分析10篇、机器学习20篇、大数据分析20篇、图像识别30篇、人工智能40篇、Python安全20篇、其他技巧10篇。
  • 汉语语法基础知识

    千次阅读 2019-02-21 16:09:00
    汉语语法有五级语法单位:语素→词→短语→句子→句群。中学语法我们重点讲词、短语和句子这三级。  1.语素  语素是语音语义的最小结合体,例如:人、吃、大、十等。语素构成词。语素可以单独成词,也可以与别的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,123
精华内容 24,049
关键字:

分析家语法