亚久久调教视频,91久久精品国产91性色,欧美丝袜一区二区

lwch — Wed, 09 Oct 2013 03:17:00 GMT

在沉默了数月之后�Q�博��d��血来潮想��l�介�l�QParserGenerator�Q�在�q�里我们��不再��l�介�l��Q何有关于LALR(1)的算�?那东西只会把你的脑子变成一团浆�p?�Q�让我们来看一下QParserGenerator的具体用法�?br />
说到ParserGenerator不得不提的是BNF�Q�应此QParserGenerator也有它自��q��BNF�Q�这时有��Z��问BNF�I�竟是什么呢�Q�简单的说BNF��是用来描述一�U�语法的东西�Q�比如在Basic中If后面跟表辑ּ�然后是Then中间是语句块末尾必须要有End If�{�等的一�p�d��描述�Q�更专业的解释我们可以看一�?a target="_blank">�l�基癄��上的解释�?br />
好了�Q�说完了BNF那让我们来看一下QParserGenerator的BNF到底是长啥样�?br />

%token "%" "token" "start" "|" "-" ">" ";" "[" "]";

%start start;

strings             -> strings "{String}"
                    |  "{String}"
                    ;

vs                  -> vs "{Letter}"
                    |  vs "{String}"
                    |  "{Letter}"
                    |  "{String}"
                    ;

option              -> "[" vs "]"
                    ;

oneProductionRight  -> oneProductionRight option
                    |  oneProductionRight vs
                    |  option
                    |  vs
                    ;

someProductionRight -> someProductionRight "|" oneProductionRight
                    |  oneProductionRight
                    ;

token               -> "%" "token" strings ";"
                    ;

someTokens          -> someTokens token
                    |  token
                    ;

production          -> "{Letter}" "-" ">" someProductionRight ";"
                    ;

someProductions     -> someProductions production
                    |  production
                    ;

start               -> someTokens "%" "start" "{Letter}" ";" someProductions
                    |  "%" "start" "{Letter}" ";" someProductions
                    ;

也许有�h会问�Q�不对啊�Ҏ��l�基癄��上的说明BNF不应该是长这��L��Q�其实QParserGenerator是一个BNF的生成器�Q�它可以��输入的BNF通过一�p�d��的运��最后生成LALR(1)分析表，��Z��BNF文�g的美观和方便处理我特地把他设计成了这个样子的而已�Q�好了下面我们就以这个BNF文�g来说明应该如何来书写BNF文�g�?br />
首先可以看到最��上有一些以%token开头的字符�Ԍ��在C语言中我们将用双引号括�v来的字符序列�U�Cؓ字符�Ԍ��以及最后的一个分��P��其实�q�里的这些字�W�串正是BNF中说说的�l�结�W�，所以我们规定，所有其他没�?token声明的符号都是非�l�结�W�。终�l�符是用来做�U�进操作的，在某�U�特定的语言中他表现��Z��个token�Q�而非�l�结�W�可以理解�ؓ一个代词，通常一个非�l�结�W�都可以展开��Z��条或多条规则�Q?a target="_blank">产生�?/a>�Q�。至于说��Z��么每条内容后面都会有分号呢，只是��Z��处理上的方便�Q�消除语法上的冲�H�？�Q��?br /> 好了�Q�我们把�l�结�W�和非终�l�符�q�两个专业术语给解释完了�Q�接下来可以看到的是一个以%start开头后跟一个非�l�结�W�的语句�Q�他表明了所有规则（产生�?/a>�Q�是从哪里开始的�Q�有始无�l�的节奏-_-||杯具啊）�?br />
最后就是我们的重头了，多空一行也不�ؓ�q�吧。这里有一大堆的��生式�Q�那我们如何来阅��M��呢，其实上面已经介绍了有个表明了所有规则开头的非终�l�符�Q�好那让我们来找一下他所对应的��生式在哪�?br />

start               -> someTokens "%" "start" "{Letter}" ";" someProductions
                    |  "%" "start" "{Letter}" ";" someProductions
                    ;

可以看到所有的规则可分为左半部分和叛_��部分�Q�左�Ҏ��L��一个非�l�结�W�来说明他应该被哪一些规则来替代�Q�而右边则是这些规则的具体内容包含了一些终�l�符和非�l�结�W�序列，中间则用一个箭头符��h��分割。在所有的规则中非�l�结�W�都是不带引��L��Q�而终�l�符都是用引号将其括��h��的，在终�l�符中有一些内�|�的变量来表达一些特定的表达式，�q�个会在下文中做��明。当然对于同一个终�l�符来说我们可以用�Q意多个规则来说明他，他们都是�?/font>的关�p�，�׃��BNF中不可能存在�?/font>的关�p�，应此我们�q�不需要考虑他�?br />
下面让我们来看一下预定义的终�l�符有哪些，�?a target="_blank">Parser.cpp的代码中可知预定义的�l�结�W�有"{String}"�?{Digit}"�?{Real}"�?{Letter}"�?br /> "{String}"�Q�表�C�正则表辑ּ�\"[^\"]*\"
"{Digit}"�Q�表�C�正则表辑ּ�[0-9]+
"{Real}"�Q�表�C�正则表辑ּ�[0-9]*.[0-9]+
"{Letter}"�Q�表�C�正则表辑ּ�((_[0-9]+)|([_a-zA-Z]+))[_0-9a-zA-Z]*
从这些正则表辑ּ�中可�?{String}"表示一个带双引��L��字符�Ԍ��"{Digit}"则表�C�Z��个数字，"{Real}"则表�C�Z��个��Q�Ҏ��Q?{Letter}"则表�C�Z��个不带双引号的字�W�串。当然这些正则表辑ּ�写的�q�不完备�Q�比�?{String}"中没有支持�{义等�{��?br />
然后让我们来看一下每条规则支持哪些语法，首先从下面几条文法中可知�Q�可用方括号��一些可选项括�v来�?br />

1 vs                  -> vs "{Letter}"
2                     |  vs "{String}"
3                     |  "{Letter}"
4                     |  "{String}"
5                     ;
6
7 option              -> "[" vs "]"
8                     ;

而对于一个规则来说他可以用若�q�条产生式来说明他，其中每条产生式之间是�?/font>的关�p�R�?br />

其他一些规则则说明了一些上文提到的规则�Q�比如开头是一些token的定义等。终于把QParserGenerator的文法文件的�l�构�l�介�l�完了，在接下来的一��文章中我们��介�l�如何用QParserGenerator来生成一个带括号优先�U�的四则混合�q�算计算器，其文法可�?a target="_blank">Calculator.txt�Q�QLanguage整个��目的代码可�?a target="_blank">https://github.com/lwch/QLanguage/�?img src ="http://www.shnenglu.com/lwch/aggbug/203576.html" width = "1" height = "1" />

lwch 2013-10-09 11:17 发表评论

QParserGenerator代码分析�?A fix&An example)

lwch — Thu, 30 May 2013 15:04:00 GMT

�?a href="http://www.shnenglu.com/lwch/archive/2013/05/12/200203.html" target="_blank">上一��?/a>�Q�首先需要修正的是在DFA生成��法中的传播部分�Q�应该需要有个��@环一直传播到不能传播为止�Q�在多次实验中表明，有些展望�W�是通过�W?�Q?�Q?甚至更多�ơ传播得来的�?br />
应此�Q�相应的make函数变成�?br />

  bool LALR1::make()
    {
        vector v;
        v.push_back(inputProductions[begin][0]);
        pStart = closure(v);
        pStart->idx = Item::inc();
        context.states.insert(pStart);
        items.push_back(pStart);

        queue q;
        q.push(pStart);

        vector changes;

        bool bContinue = false;
        while (!q.empty())
        {
            Item* pItem = q.front();
            vector s;
            symbols(pItem, s);
            select_into(s, vts, compare_production_item_is_vt, push_back_unique_vector);
            select_into(s, vns, compare_production_item_is_vn, push_back_unique_vector);
            for (vector::const_iterator i = s.begin(), m = s.end(); i != m; ++i)
            {
                Item* pNewItem = NULL;
                if (go(pItem, *i, pNewItem))
                {
                    long n = itemIndex(pNewItem);
                    if (n == -1)
                    {
                        pNewItem->idx = Item::inc();
                        q.push(pNewItem);
                        items.push_back(pNewItem);
                        context.states.insert(pNewItem);
                    }
                    else
                    {
                        items[n]->mergeWildCards(pNewItem, bContinue);
                        changes.push_back_unique(items[n]);
                        destruct(pNewItem, has_destruct(*pNewItem));
                        Item_Alloc::deallocate(pNewItem);
                    }
                    edges[pItem].push_back_unique(Edge(pItem, n == -1 ? pNewItem : items[n], *i));
                }
            }
            q.pop();
        }
        while (bContinue)
        {
            vector v;
            v.reserve(changes.size());
            bContinue = false;
            for (vector::const_iterator i = changes.begin(), m = changes.end(); i != m; ++i)
            {
                vector s;
                symbols(*i, s);
                for (vector::const_iterator j = s.begin(), n = s.end(); j != n; ++j)
                {
                    Item* pNewItem = NULL;
                    if (go(*i, *j, pNewItem))
                    {
                        long n = itemIndex(pNewItem);
                        if (n == -1) throw error<const char*>("unknown item", __FILE__, __LINE__);
                        else
                        {
                            items[n]->mergeWildCards(pNewItem, bContinue);
                            v.push_back_unique(items[n]);
                            destruct(pNewItem, has_destruct(*pNewItem));
                            Item_Alloc::deallocate(pNewItem);
                        }
                    }
                }
            }
            changes = v;
        }
    }

在merge函数中，会检��有没有新生成的展望�W�来军_��是否�l�箋传播下去�?br />
一个示�?/strong>
下面我们用一个例子来说明LALR1 DFA是如何生成的�Q�首先它的文法如�?br />
S -> L "=" R
  | R "+"
  | R
  ;

L -> "*" R
  |  "id"
  ;

R -> L
  ;
�Ҏ��之前的算法，我们先来看自生的部分

首先我们写出�q�个文法的增�q�文�?br />
begin -> . S (#)
求取它的闭包得到

begin -> . S
wildCards:
#
S -> . L "=" R
wildCards:
#
S -> . R "+"
wildCards:
#
S -> . R
wildCards:
#
L -> . "*" R
wildCards:
"=" "+"
L -> . "id"
wildCards:
"=" "+"
R -> . L
wildCards:
"+" #
我们观察刎ͼ�其中�?个可转移的符��P��分别为S、L、R�?*"�?id"�Q�我们分别用go函数对这5个�{�Uȝ��h��出新的状�?br />
首先用符号S求出新状�?br />
begin -> S
wildCards:
#
�׃��q�个状态不在原有列表中�Q�应此它是一个新生成的状态，我们为它��d��一条通过�W�号S转移的边�?br />
接下来用�W�号L求出新状�?br />
S -> L . "=" R
wildCards:
#
R -> L
wildCards:
"+" #
�q�个状态也不在原有列表中，应此它也是一个新生成的状态，我们为它��d��一条通过�W�号L转移的边�?br />
然后用符号R求出新状�?br />
S -> R . "+"
wildCards:
#
S -> R
wildCards:
#
�q�个状态也不在原有列表中，应此它也是一个新生成的状态，我们为它��d��一条通过�W�号R转移的边�?br />
然后用符�?求出新的状�?br />
L -> "*" . R
wildCards:
"=" "+"
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #
同样的它也不在原有的列表中，我们同样为其��d��一条通过�W�号*转移的边�?br />
然后是符号id�?br />
L -> "id"
wildCards:
"=" "+"
同样不在列表中，我们为其��d��一条通过�W�号id转移的边�?br />
�q�样�Q�从start状态�{�U�d��来的5条边��q��成好了，下面来看看这5个新生成的状态又会生成一些什么呢

begin -> S
wildCards:
#
��q��一个状态可知，它没有�Q何的辏V�?br />

S -> L . "=" R
wildCards:
#
R -> L
wildCards:
"+" #
�W�二个状态则有一�?的�{�U�，它生成了一个新状�?br />
S -> L "=" . R
wildCards:
#
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #

S -> R . "+"
wildCards:
#
S -> R
wildCards:
#
�W�三个状态有一�?的�{�U�，它生成了一个新状�?br />
S -> R "+"
wildCards:
#

L -> "*" . R
wildCards:
"=" "+"
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #
�W�四个状态有4个�{�U�，分别为R、L�?和id

1.通过�W�号R转移到新状�?br />
L -> "*" R
wildCards:
"=" "+"

2.通过�W�号L转移到新状�?br />
R -> L
wildCards:
"+" # "="

3.通过*则可转移到它自己

4.通过id转移到第5个状�?br />
�W�五个状态则没有��M��的�{�U�R�?br />

S -> L "=" . R
wildCards:
#
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #
�W�六个状态有4个�{�U�，分别为R、L�?和id

1.通过�W�号R可�{�U�d��新状�?br />
S -> L "=" R
wildCards:
#

2.通过�W�号L可�{�U�d��状�?

3.通过�W�号*可�{�U�d��状�?

4.通过�W�号id可�{�U�d��状�?

�W?�?�?个状态都没有��M��转移

然后让我们来看下changes列表里有哪些东西�Q�根�?a href="http://www.shnenglu.com/lwch/archive/2013/05/12/200203.html" target="_blank">上一��?/a>的算法可知，所有已存在的状态都在changes列表里，应此它里面应该会�?�?�?三个状态�?br />
��x��Q�整个自生的部分完成了，下面我们��其��L��一张图

下面是传播部�?/strong>
在第一�ơ传播时changes列表里有3个状态，分别对这3个状态用go函数求出新的展望�W�，�q�把它们合�ƈ到原有的状态上�?br />
首先看状�?�Q�它�?个状态�{�Uȝ��Q�分别是R、L�?和id

1.通过�W�号R可�{�U�d��状�?�Q�同时它的展望符如下

L -> "*" R
wildCards:
"=" "+" #

2.通过�W�号L可�{�U�d��状�?�Q�同时它的展望符如下

R -> L
wildCards:
"+" # "="

3.通过�W�号*可�{�U�d��它自己，同时它的展望�W�如�?br />
L -> "*" . R
wildCards:
"=" "+" #
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #

4.通过�W�号id可�{�U�d��状�?�Q�同时它的展望符如下

L -> "id"
wildCards:
"=" "+" #

然后我们来看一下状�?�?�Q�它们没有�Q何状态�{�Uȝ��Q�应此它们不会传播�Q何展望符�?br />
现在changes列表里有4个状态，分别�?�?�?�?�Q�又�׃��W?个状态已�l��生了新的展望�W?应此需要��l�传�?br />
�W�二�ơ传�?/strong>

首先先看状�?�?�Q�它们没有�Q何状态�{�Uȝ��Q�应此它们不会传播�Q何展望符�?br />
然后来看状�?�Q�同��L��它有4个状态�{�Uȝ��Q�分别�ؓR、L�?和id�?br />
1.通过�W�号R可�{�U�d��状�?�Q�同时它的展望符如下

L -> "*" R
wildCards:
"=" "+" #

2.通过�W�号L可�{�U�d��状�?�Q�同时它的展望符如下

R -> L
wildCards:
"+" # "="

3.通过�W�号*可�{�U�d��它自己，同时它的展望�W�如�?br />
L -> "*" . R
wildCards:
"=" "+" #
R -> . L
wildCards:
"+" # "="
L -> . "*" R
wildCards:
"=" "+" #
L -> . "id"
wildCards:
"=" "+" #

4.通过�W�号id可�{�U�d��状�?�Q�同时它的展望符如下

L -> "id"
wildCards:
"=" "+" #

最后我们来看状�?�Q�它没有��M��状态�{�Uȝ��Q�应此它不会传播��M��展望�W��?br />
现在changes列表里同��h��4个状态，分别�?�?�?�?�Q�由于没有一个状态��生了新的展望�W�，应此它将不会�l�箋传播下去了�?br />
现在整个文法的DFA��q��成完毕了�Q�让我们来修改一下原先的那张图来看看最�l�的DFA是什么样的�?br />

整个�C�Z��先介绍到这里，在接下来的一��文章中��会通过几个�C�Z��来介�l�closure和go函数的原理，希望�q�种��q��到细的讲解顺序能够被读者所接受。最后完整的代码可到http://code.google.com/p/qlanguage下蝲�?img src ="http://www.shnenglu.com/lwch/aggbug/200608.html" width = "1" height = "1" />

lwch 2013-05-30 23:04 发表评论

QParserGenerator代码分析一(生成LALR1 DFA)

lwch — Sun, 12 May 2013 14:32:00 GMT
     摘要: 以下所说的文法文�g均�ؓQParserGenerator的文法文�? 产生�?我们��文法文件中形如 Code highlighting produced by Actipro CodeHighlighter (freeware) http://www.CodeHighlighter.com/ -->strings     &n...  阅读全文

lwch 2013-05-12 22:32 发表评论

词法分析�?(ε-NFA到DFA的�{�?

lwch — Sat, 23 Feb 2013 15:30:00 GMT

�?a href="http://www.shnenglu.com/lwch/archive/2013/02/15/197848.html" target="_blank">上一��?/a>我们已经得到了一个完整的ε-NFA�Q�下面来说说如何��?#949;-NFA转换为DFA�Q�确定有限自动机�Q��?/p>

DFA的状�?/h1>
在DFA中，某个状态对应到ε-NFA中的若干状态，应此我们��会得到下面�q�样的一个结构�?/p>

struct DFA_State { set content; bool bFlag; #ifdef _DEBUG uint idx; #endif DFA_State(const set& x) : content(x), bFlag(false) { #ifdef _DEBUG idx = inc(); #endif } inline const bool operator==(const DFA_State& x)const { if (&x == this) return true; return content == x.content; } #ifdef _DEBUG inline uint inc() { static uint i = 0; return i++; } #endif };

可以看到�Q��ؓ了调试方便我们在�l�构中定义了状态的唯一ID以及对应�?#949;-NFA状态的集合和一个标��C��?/p>
DFA的边

�Ҏ��上一��?/a>的经验，不难惛_��DFA的边应该是什么样的，下面直接�l�出代码�Q�不做说明�?/p>

struct DFA_Edge { struct { Char_Type char_value; String_Type string_value; }data; enum Edge_Type { TUnknown = 0, TNot = 1, TChar = 2, TString = 4 }; uchar edge_type; DFA_State* pFrom; DFA_State* pTo; DFA_Edge(const Char_Type& x, bool bNot, DFA_State* pFrom, DFA_State* pTo) : pFrom(pFrom), pTo(pTo) { data.char_value = x; edge_type = bNot ? (TChar | TNot) : TChar; } DFA_Edge(const String_Type& x, bool bNot, DFA_State* pFrom, DFA_State* pTo) : pFrom(pFrom), pTo(pTo) { data.string_value = x; edge_type = bNot ? (TString | TNot) : TString; } inline const bool isNot()const { return (edge_type & TNot) == TNot; } inline const bool isChar()const { return (edge_type & TChar) == TChar; } inline const bool isString()const { return (edge_type & TString) == TString; } const Edge_Type edgeType()const { if (isChar()) return TChar; else if (isString()) return TString; else return TUnknown; } const bool operator<(const DFA_Edge& x)const { return (ulong)pFrom + pTo < (ulong)x.pFrom + x.pTo; } const bool operator==(const DFA_Edge& x)const { return pFrom == x.pFrom && pTo == x.pTo; } };

�׃��DFA中不存在ε边，应此DFA��会存在若干个结束状态，但他只有一个开始状�?/p>

DFA_State* pDFAStart; set pDFAEnds; set dfa_Edges;

��Z��下一步分析的高效�Q�以后可能会��这里的dfa_Edges同样修改为hashmap�?/p>
��x��DFA所要用到的两个�l�构�q�速的介绍完了�?/p>
子集构造算�?/h1>
通过各种资料�Q�我们不隑֏�玎ͼ��?#949;-NFA转换到DFA的过�E�中�Q�最常用��是子集构造算法。子集构造算法的主要思想�?strong>让DFA的每个状态对应NFA的一个状态集。这个DFA用它的状态去��C��NFA在读输入�W�号后达到的所有状态�?/strong>�Q�引自编译原理）其算法如�?/p>

输入�Q�一个NFA N�? 输出�Q�一个接受同栯��a�的DFA D�? �Ҏ��Q? 1.求取ε-NFA初始状态的ε闭包作�ؓDFA的�v始状态，�q�将�q�个状态加入集合C中，且它是未标记的。同时记录它的向后字�W�集�? 2.从集合C中取��Z��个未被标记的子集T和其对应的字�W�集�Q�标记子集T�? 3.使用上一步取出的字符集通过状态�{�U�d��数求��{�U�d��的状态集M�? 4.求取上一步得到的状态集M�?#949;闭包U 5.如果U不在集合C中则��U作�ؓ未被标记的子集加入C中，同时记录它的向后字符集。检查状态U中是否存在NFA中的�l�结状态，若存在则��状态U加入到pDFAEnds中�? 重复2�Q?�Q?�Q?部直至集合C中不存在未被标记的状态�?/pre>

ε闭包

ε闭包是指从某个状态�v只经�q?#949;边达到的其他状态的集合�Q�同时这个状态也属于�q�个集合中。其��法如下

输入�Q�状态集k�? 输出�Q�状态集U和其所对应的向后字�W�集�? �Ҏ��Q? 1.遍历状态集k中的每个状态k'�? 2.若k'不存在于�l�果状态集U中，��k'插入U中�? 3.建立一个��旉��合tmp�Q��ƈ��k'插入其中�? 4.从��旉��合tmp中取��Z��个状态p�? 5.取出所有从p出发的边�Q�若�q�条�Ҏ��ε边，且抵辄��态不在结果状态集U中，��抵辄��状态分别插入结果状态集U和��旉��合tmp中。若�q�条�Ҏ��字符集的边且�q�条�Ҏ��对应的字�W�不在向后字�W�集中，则将向后字符插入向后字符集中�? 6.��状态p从��旉��合tmp中删除�? 循环4�Q?�Q?部直至tmp中不存在��M��状态�ؓ止�?/pre>

�׃��在生�?#949;-NFA时不存在只有ε边的循环�Q�应此这里不会��生死循环。下面给出具体的代码

void epsilonClosure(const set& k, EpsilonClosureInfo& info) { for (typename set::const_iterator i = k.begin(), m = k.end(); i != m; ++i) { info.states.insert(*i); set tmp; tmp.insert(*i); while (!tmp.empty()) { EpsilonNFA_State* pState = *tmp.begin(); for (typename vector::const_iterator j = epsilonNFA_Edges[pState].begin(), n = epsilonNFA_Edges[pState].end(); j != n; ++j) { if (j->isEpsilon()) { if (info.states.insert(j->pTo).second) tmp.insert(j->pTo); } else if (j->isChar()) info.chars.insert(pairbool>(j->data.char_value, j->isNot())); else if (j->isString()) info.strings.insert(pairbool>(j->data.string_value, j->isNot())); } tmp.erase(pState); } } }

其中用到的EpsilonClosureInfo�l�构�?/p>

struct EpsilonClosureInfo { set states; setbool> > chars; setbool> > strings; EpsilonClosureInfo() {} EpsilonClosureInfo(const set& states, const setbool> >& chars, const setbool> >& strings) : states(states) , chars(chars) , strings(strings) {} EpsilonClosureInfo(const EpsilonClosureInfo& x) { states = x.states; chars = x.chars; strings = x.strings; } };

需要保存的是状态集和向后字�W�集�?/p>
状态�{�U�d��?/h2>
通过状态�{�U�d��敎ͼ�输入一个集合T和一个字�W�a��可得到所有通过T中的每一个状态和a�Ҏ��能达到的状态的集合。应此代码如�?/p>

set move(const DFA_State& t, const Char_Type& c, bool bNot) { set result; for (typename set::const_iterator i = t.content.begin(), m = t.content.end(); i != m; ++i) { for (typename vector::const_iterator j = epsilonNFA_Edges[*i].begin(), n = epsilonNFA_Edges[*i].end(); j != n; ++j) { if (j->isChar() && j->data.char_value == c && j->isNot() == bNot) result.insert(j->pTo); } } return result; } set move(const DFA_State& t, const String_Type& s, bool bNot) { set result; for (typename set::const_iterator i = t.content.begin(), m = t.content.end(); i != m; ++i) { for (typename vector::const_iterator j = epsilonNFA_Edges[*i].begin(), n = epsilonNFA_Edges[*i].end(); j != n; ++j) { if (j->isString() && j->data.string_value == s && j->isNot() == bNot) result.insert(j->pTo); } } return result; }

��Z��分别支持Char_Type和String_Type的字�W�我们定义了两个move函数�?/p>
最后我们给出子集构造算法的代码

void buildDFA() { set start; start.insert(pEpsilonStart); typedef pair c_type; map > c; queue c2; pDFAStart = DFA_State_Alloc::allocate(); EpsilonClosureInfo info; epsilonClosure(start, info); construct(pDFAStart, info.states); c_type ct(pDFAStart, info); c[info.states.size()].push_back(ct); c2.push(ct); if (isEndDFAStatus(pDFAStart)) pDFAEnds.insert(pDFAStart); context.dfa_States.insert(pDFAStart); while (!c2.empty()) { DFA_State* t = c2.front().first; setbool> > chars = c2.front().second.chars; setbool> > strings = c2.front().second.strings; t->bFlag = true; for (typename setbool> >::const_iterator i = chars.begin(), m = chars.end(); i != m; ++i) { EpsilonClosureInfo info; epsilonClosure(move(*t, i->first, i->second), info); DFA_State* p = getDFAState(info.states, c); if (p) // 如果�q�个状态已存在 { dfa_Edges.insert(DFA_Edge(i->first, i->second, t, p)); } else { DFA_State* pState = DFA_State_Alloc::allocate(); construct(pState, info.states); context.dfa_States.insert(pState); if (isEndDFAStatus(pState)) pDFAEnds.insert(pState); c_type ct(pState, info); c[info.states.size()].push_back(ct); c2.push(ct); dfa_Edges.insert(DFA_Edge(i->first, i->second, t, pState)); } } for (typename setbool> >::const_iterator i = strings.begin(), m = strings.end(); i != m; ++i) { EpsilonClosureInfo info; epsilonClosure(move(*t, i->first, i->second), info); DFA_State* p = getDFAState(info.states, c); if (p) // 如果�q�个状态已存在 { dfa_Edges.insert(DFA_Edge(i->first, i->second, t, p)); } else { DFA_State* pState = DFA_State_Alloc::allocate(); construct(pState, info.states); context.dfa_States.insert(pState); if (isEndDFAStatus(pState)) pDFAEnds.insert(pState); c_type ct(pState, info); c[info.states.size()].push_back(ct); c2.push(ct); dfa_Edges.insert(DFA_Edge(i->first, i->second, t, pState)); } } c2.pop(); } }

��֣�

同样我们来编写一个函数来打印出DFA�?/p>

void printDFA() { printf("---------- DFA Start ----------\n"); set tmp; for (typename set::const_iterator i = dfa_Edges.begin(), m = dfa_Edges.end(); i != m; ++i) { printf("%03d -> %03d", i->pFrom->idx, i->pTo->idx); switch (i->edgeType()) { case DFA_Edge::TChar: printf("(%c)", i->data.char_value); break; case DFA_Edge::TString: printf("(%s)", i->data.string_value.c_str()); break; default: break; } if (i->isNot()) printf("(not)"); printf("\n"); tmp.insert(i->pFrom); tmp.insert(i->pTo); } printf("start: %03d -> ends: ", pDFAStart->idx); for (typename set::const_iterator i = pDFAEnds.begin(), m = pDFAEnds.end(); i != m; ++i) { printf("%03d ", (*i)->idx); } printf("\n"); #if DEBUG_LEVEL == 3 printf("-------------------------------\n"); for (typename set::const_iterator i = tmp.begin(), m = tmp.end(); i != m; ++i) { printf("State: %03d\n", (*i)->idx); for (typename set::const_iterator j = (*i)->content.begin(), n = (*i)->content.end(); j != n; ++j) { printf("%03d ", (*j)->idx); } printf("\n"); } #endif printf("----------- DFA End -----------\n"); }

最后我们加入测试代�?/p>

Rule_Type::Context context; Rule_Type a('a', context), b('b', context), d('d', context); Rule_Type result = (a - d).opt() + (+b | !(a + b)); result.buildDFA(); #ifdef _DEBUG result.printEpsilonNFA(); result.printDFA(); #endif

可打印出如下内容



��L��囑֦��?/p>

完整的代码可�?a target="_blank">http://code.google.com/p/qlanguage下蝲

lwch 2013-02-23 23:30 发表评论

词法分析�?(正则表达式到ε-NFA的�{�?

lwch — Fri, 15 Feb 2013 12:29:00 GMT

自动�?/h1>
关于自动机的说明�Q�这里不不再复述�Q�请�?a href="http://zh.wikipedia.org/wiki/自动�? target="_blank">http://zh.wikipedia.org/wiki/自动�?/a>查看�?/p>
表达�?/h1>
首先�Q�我们规定表辑ּ�中只允许输入Char_Type和String_Type�c�d��的字�W��?/p>

template class Rule { };

ε-NFA的状�?/h1>
对于一个状态来��_��我们�q�不需要知道他的�Q何信�?/p>
在上面的代码中，��Z��调试方便�Q�我为其加入了idx域，�q��ؓ每个状态分配了一个唯一的ID�?/p>

struct EpsilonNFA_State { #ifdef _DEBUG uint idx; EpsilonNFA_State() { idx = inc(); } static uint inc() { static uint i = 0; return i++; } #else EpsilonNFA_State() {} #endif };

ε-NFA的边

ε-NFA中的辚w��是有向的。对于�Q意一条边来说�Q�最重要的是他的两个端点是谁以及�q�条�Ҏ��对应的字�W�集�Q�若�q�条边不�?#949;边）�?/p>

struct EpsilonNFA_Edge { struct { Char_Type char_value; String_Type string_value; }data; enum Edge_Type { TUnknown = 0, TNot = 1, TChar = 2, TString = 4, TEpsilon = 8 }; uchar edge_type; EpsilonNFA_State* pFrom; EpsilonNFA_State* pTo; EpsilonNFA_Edge(EpsilonNFA_State* pFrom, EpsilonNFA_State* pTo) : edge_type(TEpsilon), pFrom(pFrom), pTo(pTo) {} EpsilonNFA_Edge(const Char_Type& x, EpsilonNFA_State* pFrom, EpsilonNFA_State* pTo) : edge_type(TChar), pFrom(pFrom), pTo(pTo) { data.char_value = x; } EpsilonNFA_Edge(const String_Type& x, EpsilonNFA_State* pFrom, EpsilonNFA_State* pTo) : edge_type(TString), pFrom(pFrom), pTo(pTo) { data.string_value = x; } inline void negate() { edge_type ^= TNot; } inline const bool isNot()const { return (edge_type & TNot) == TNot; } inline const bool isEpsilon()const { return (edge_type & TEpsilon) == TEpsilon; } inline const bool isChar()const { return (edge_type & TChar) == TChar; } inline const bool isString()const { return (edge_type & TString) == TString; } const Edge_Type edgeType()const { if (isEpsilon()) return TEpsilon; else if (isChar()) return TChar; else if (isString()) return TString; else return TUnknown; } };

有了以上两个�l�构之后�Q�我们�ؓRule��d��三个成员变量

EpsilonNFA_State *pEpsilonStart, *pEpsilonEnd; hashmap, _hash> epsilonNFA_Edges;

pEpsilonStart和pEpsilonEnd分别表示�q�条表达式所对应状态机的start和end状态，epsilonNFA_Edges则是以某个状态作为key�Q�从�q�个状态到辑֏�一个状态所�l�过的边作�ؓvalue的hash表�?/p>
生成状态机

�l�于��C��正题�Q�首先，我们把所有的关系分�ؓ串联关系、�ƈ联关�p�R��可选关�p�R�?�ơ及以上的重复关�p�R��至��?�ơ以上的重复关系和取反关�p�R��下面分别介�l�每�U�关�pȝ��ε-NFA如何来生成。（下文中若没有指出�q�接边的�c�d��则是ε�?/strong>�Q?/p>
字符�?/h2>
正如上文所��_��字符集包括Char_Type和String_Type�c�d��的字�W�，应此生成字符集的状态机��比较简单了�Q�只需创徏��Z��个状态，然后通过一条经�q�这个字�W�集的边��这两个状态按照某个方向连接，最后将一个状态标��Cؓstart状态，另一个状态标��Cؓend状态即可�?/p>

Rule(const Char_Type& x, Context& context) : pDFAStart(NULL), context(context) { pEpsilonStart = EpsilonNFA_State_Alloc::allocate(); construct(pEpsilonStart); pEpsilonEnd = EpsilonNFA_State_Alloc::allocate(); construct(pEpsilonEnd); epsilonNFA_Edges[pEpsilonStart].push_back(EpsilonNFA_Edge(x, pEpsilonStart, pEpsilonEnd)); context.epsilonNFA_States.insert(pEpsilonStart); context.epsilonNFA_States.insert(pEpsilonEnd); } Rule(const String_Type& x, Context& context) : pDFAStart(NULL), context(context) { pEpsilonStart = EpsilonNFA_State_Alloc::allocate(); construct(pEpsilonStart); pEpsilonEnd = EpsilonNFA_State_Alloc::allocate(); construct(pEpsilonEnd); epsilonNFA_Edges[pEpsilonStart].push_back(EpsilonNFA_Edge(x, pEpsilonStart, pEpsilonEnd)); context.epsilonNFA_States.insert(pEpsilonStart); context.epsilonNFA_States.insert(pEpsilonEnd); }

串联关系

串联关系中，只需要将前一个状态机的end状态通过ε边连接到另一个状态机的start状态，最后将前一个状态的start状态标��Cؓ新状态机的start状态，后一个状态机的end状态标��Cؓ新状态机的end状态即可�?/p>

self operator+(const self& x) { self a = cloneEpsilonNFA(*this), b = cloneEpsilonNFA(x); copyEpsilonNFA_Edges(b, a); a.epsilonNFA_Edges[a.pEpsilonEnd].push_back(EpsilonNFA_Edge(a.pEpsilonEnd, b.pEpsilonStart)); a.pEpsilonEnd = b.pEpsilonEnd; return a; }

�q�联关系

�q�联关系中，需要分别新��Z��个start和end状态做为新状态机的start和end状态，然后��新生成的start状态分别连接到原状态机的start状态，原状态机的end状态连接到新生成的end状态即可�?/p>

self operator|(const self& x) { self a = cloneEpsilonNFA(*this), b = cloneEpsilonNFA(x); copyEpsilonNFA_Edges(b, a); EpsilonNFA_State* _pStart = EpsilonNFA_State_Alloc::allocate(); construct(_pStart); EpsilonNFA_State* _pEnd = EpsilonNFA_State_Alloc::allocate(); construct(_pEnd); context.epsilonNFA_States.insert(_pStart); context.epsilonNFA_States.insert(_pEnd); a.epsilonNFA_Edges[_pStart].push_back(EpsilonNFA_Edge(_pStart, a.pEpsilonStart)); a.epsilonNFA_Edges[_pStart].push_back(EpsilonNFA_Edge(_pStart, b.pEpsilonStart)); a.epsilonNFA_Edges[a.pEpsilonEnd].push_back(EpsilonNFA_Edge(a.pEpsilonEnd, _pEnd)); a.epsilonNFA_Edges[b.pEpsilonEnd].push_back(EpsilonNFA_Edge(b.pEpsilonEnd, _pEnd)); a.pEpsilonStart = _pStart; a.pEpsilonEnd = _pEnd; return a; }

重复关系

在正则表辑ּ�中存在�Ş�?a)+�?a)*的两�U�重复关�p�，对于�q�两�U�重复关�p�，生成的状态机的区别仅在于end状态对于一�ơ以上的重复�Q�只需要给原状态机��d��一条从end状态到start状态的ε边即可。而对于零�ơ以上的重复�Q�不光需要添�?#949;边，同时需要将新状态机的end状态标��Cؓstart状态，因�ؓ零次重复时不需要经�q��Q意边既可被接受�?/p>

self operator*() { self a = cloneEpsilonNFA(*this); a.epsilonNFA_Edges.insert(EpsilonNFA_Edge(a.pEpsilonEnd, a.pEpsilonStart)); a.pEpsilonEnd = a.pEpsilonStart; return a; } self operator+() { self a = cloneEpsilonNFA(*this); a.epsilonNFA_Edges[a.pEpsilonEnd].push_back(EpsilonNFA_Edge(a.pEpsilonEnd, a.pEpsilonStart)); return a; }

上面�q�三�U�是最基本的生成方法，通过以上�q�三�U�生成方法已��_��应付多数的表辑ּ��?/p>
一些拓�?/h1>
下面来看看一些拓展�Ş式的状态机是如何生成的�?/p>
可选关�p?/h2>
在可选关�p�M��Q�只需要给原状态机��d��一条从start状态到end状态的ε边即可。由�?#949;-NFA只允许有一个start和end状态的关系�Q�应此当条�g不成立时从start状态就可直接通过ε边到达end状态�?/p>

inline self opt() { self a = cloneEpsilonNFA(*this); a.epsilonNFA_Edges[a.pEpsilonStart].push_back(EpsilonNFA_Edge(a.pEpsilonStart, a.pEpsilonEnd)); return a; }

取反关系

�׃��我们只处理Char_Type和String_Type�c�d��的字�W�集�Q�应此对于取反我们只需要将当前状态机内所有类型�ؓTChar或TString�c�d��的边取一下反卛_��Q?strong>需要注意的是可能存在负负得正的情况�Q�既取偶数次反等于没取反�Q?/p>

self operator!() { self a = cloneEpsilonNFA(*this); for (typename hashmap, _hash>::iterator i = a.epsilonNFA_Edges.begin(), m = a.epsilonNFA_Edges.end(); i != m; ++i) { for (typename vector::iterator j = i->second.begin(), n = i->second.end(); j != n; ++j) { if (j->isChar() || j->isString()) j->negate(); } } return a; }

Char-Char关系

所谓的char-char关系��是正则表达式中的[a-z]表达式。其实这是一�U��ƈ联关�pȝ��拓展�Q�由两个原始状态机拓展��C��N个，生成�Ҏ��也类伹{�?/p>

self operator-(const self& x) { self a = cloneEpsilonNFA(*this); if (epsilonNFA_Edges.size() == 1 && x.epsilonNFA_Edges.size() == 1 && epsilonNFA_Edges.begin()->second.size() == 1 && x.epsilonNFA_Edges.begin()->second.size() == 1 && epsilonNFA_Edges.begin()->second.begin()->edge_type == EpsilonNFA_Edge::TChar && x.epsilonNFA_Edges.begin()->second.begin()->edge_type == EpsilonNFA_Edge::TChar) { EpsilonNFA_State* _pStart = EpsilonNFA_State_Alloc::allocate(); construct(_pStart); EpsilonNFA_State* _pEnd = EpsilonNFA_State_Alloc::allocate(); construct(_pEnd); context.epsilonNFA_States.insert(_pStart); context.epsilonNFA_States.insert(_pEnd); a.epsilonNFA_Edges[_pStart].push_back(EpsilonNFA_Edge(_pStart, a.pEpsilonStart)); a.epsilonNFA_Edges[a.pEpsilonEnd].push_back(EpsilonNFA_Edge(a.pEpsilonEnd, _pEnd)); const Char_Type chStart = epsilonNFA_Edges.begin()->second.begin()->data.char_value; const Char_Type chEnd = x.epsilonNFA_Edges.begin()->second.begin()->data.char_value; for (Char_Type ch = chStart + 1; ch < chEnd; ++ch) { self y(ch, context); copyEpsilonNFA_Edges(y, a); a.epsilonNFA_Edges[_pStart].push_back(EpsilonNFA_Edge(_pStart, y.pEpsilonStart)); a.epsilonNFA_Edges[y.pEpsilonEnd].push_back(EpsilonNFA_Edge(y.pEpsilonEnd, _pEnd)); } self b = cloneEpsilonNFA(x); copyEpsilonNFA_Edges(b, a); a.epsilonNFA_Edges[_pStart].push_back(EpsilonNFA_Edge(_pStart, b.pEpsilonStart)); a.epsilonNFA_Edges[b.pEpsilonEnd].push_back(EpsilonNFA_Edge(b.pEpsilonEnd, _pEnd)); a.pEpsilonStart = _pStart; a.pEpsilonEnd = _pEnd; } else { throw error<string>("doesn't support", __FILE__, __LINE__); } return a; }

��֣�

让我们来�~�写一个函数来打印出整个生成后的状态机�?/p>

void printEpsilonNFA() { printf("-------- ε- NFA Start --------\n"); for (typename hashmap, _hash>::const_iterator i = epsilonNFA_Edges.begin(), m = epsilonNFA_Edges.end(); i != m; ++i) { for (typename vector::const_iterator j = i->second.begin(), n = i->second.end(); j != n; ++j) { printf("%03d -> %03d", j->pFrom->idx, j->pTo->idx); switch (j->edgeType()) { case EpsilonNFA_Edge::TEpsilon: printf("(ε)"); break; case EpsilonNFA_Edge::TChar: printf("(%c)", j->data.char_value); break; case EpsilonNFA_Edge::TString: printf("(%s)", j->data.string_value.c_str()); break; default: break; } if (j->isNot()) printf("(not)"); printf("\n"); } } printf("start: %03d -> end: %03d\n", pEpsilonStart->idx, pEpsilonEnd->idx); printf("--------- ε- NFA End ---------\n"); }

最后我们来�~�写一些测试代码来试试生成效果如何

Rule_Type::Context context; Rule_Type a('a', context), b('b', context), d('d', context); Rule_Type result = (a - d).opt() + (+b | !(a + b)); #ifdef _DEBUG result.printEpsilonNFA(); #endif

可打印出如下内容

最后�Ş成�Ş如下囄��状态机

完整的代码可�?a target="_blank">http://code.google.com/p/qlanguage下蝲�?/p>

lwch 2013-02-15 20:29 发表评论

修复了一个关于CParser_Input的Bug

lwch — Sun, 10 Jul 2011 14:13:00 GMT

我们先了看下Alt�l�合子的分析代码
1     virtual O Parser(I& input)
2     {
3         I temp = input;
4         if(O Result = left.Parser(input)) return Result;
5         input = temp;
6         if(O Result = right.Parser(input)) return Result;
7         input = temp;
8         O Result(GetMM());
9         return Result;
10     }
当left分析��p�|时会��原先的input值重新赋值给input,但此时�ƈ没有改变SymbolStack和StringStack,应此当第一�ơ分析失败时SymbolStack和StringStack中会包含一些重复的�?当然其他�l�合子同样存在这个问�?
应此我�ؓCParser_Input增加了两个成员变量保存此时的SymbolStack和StringStack的Size,当SymbolStack和StringStack Push的时候同时增加input相应的�?
最后重载CParser_Input的operator=赋值操作符,在其中根据原先的SymbolStack和StringStack的Size来弹出相应数量的重复�?br />
1     CParser_Input& operator=(CParser_Input& _value)
2     {
3         LexerTokenList = _value.LexerTokenList;
4         index = _value.index;
5
6         if(_value.symbolCount < symbolCount && _value.symbolCount)
7         {
8             int Count = symbolCount - _value.symbolCount;
9             for(int i=0;i<Count;i++) SymbolStack.Pop();
10         }
11
12         if(_value.stringCount < stringCount && _value.stringCount)
13         {
14             int Count = stringCount - _value.stringCount;
15             for(int i=0;i<Count;i++) StringStack.Pop();
16         }
17
18         symbolCount = SymbolStack.Size();
19         stringCount = StringStack.Size();
20         return *this;
21     }
以此来解决SymbolStack和StringStack的同步问�?

lwch 2011-07-10 22:13 发表评论

QLanguage的AST

lwch — Fri, 01 Jul 2011 13:51:00 GMT
QLanguage开源项目地址�Q?a target="_blank">http://qlanguage.codeplex.com

1.AST的每个节点由2个域�l�成,�q?个域分别表示当前节点的类型和附加信息�?br />2.AST的每个节点包含一个指向其子节点的��序表�?br />3.AST的每个节点包含指向下一个节点的指针�?br />�l�g��所�q�我们得到AST节点的代码：
1     class CSyntaxTreeNode
2     {
3     public:
4         CSyntaxTreeNode(int _type,int _value) : type(_type),value(_value){}
5
6         inline List<NAutoPtr<CSyntaxTreeNode>>& Child()
7         {
8             return child;
9         }
10
11         inline NAutoPtr<CSyntaxTreeNode> Next()
12         {
13             return next;
14         }
15
16         inline int& Type()
17         {
18             return type;
19         }
20
21         inline int& Value()
22         {
23             return value;
24         }
25     protected:
26         int type;
27         int value;
28         List<NAutoPtr<CSyntaxTreeNode>> child;
29         NAutoPtr<CSyntaxTreeNode> next;
30     };
然后我们�l�出了部分枚举来标识节点的类型：

1         // for type
2         enum TYPE
3         {
4             stNull,
5             stDeclare,
6             stFunction,
7             stParamterList,
8             stIf,
9             stDo,
10             stExp,
11         };
最后是一��AST的整体结构：

1 class CParserAnalyze
2 {
3 public:
4     inline void Push(NAutoPtr<CSyntaxTreeNode>& Node)
5     {
6         SyntaxTreeStack.Push(Node);
7     }
8
9     inline NAutoPtr<CSyntaxTreeNode> Pop()
10     {
11         return SyntaxTreeStack.Pop();
12     }
13
14     inline NAutoPtr<CSyntaxTreeNode> Top()
15     {
16         return SyntaxTreeStack.Top();
17     }
18
19     inline NAutoPtr<CSyntaxTreeNode> Root()
20     {
21         return SyntaxTreeRoot;
22     }
23 protected:
24     NAutoPtr<CSyntaxTreeNode> SyntaxTreeRoot;            // 语法树根节点
25     Stack<NAutoPtr<CSyntaxTreeNode>> SyntaxTreeStack;    // 语法树栈
26 };

�q�里我们��单的分析一下分析过�E�：
以if语句��Z��Q�其�l�合子代码�ؓ�Q?br />
1     if_desc = (str_if + exp_desc)[if_desc_first] +
2             (str_then + stmt_list)[if_desc_second] +
3             Parser_Combinator_Node::opt((str_else + stmt_list)[if_desc_third]) +
4             (str_end + str_if)[if_desc_fourth];
我们输入代码�Q?br />
1     if a then
2         declare b as integer
3     end if
在做语法分析�Q?br />1.��d��if a�Q�a被归�U��ؓ一条exp生成一个类型�ؓexp的节点�ƈ压入AST的语法树栈�?br />2.if a被归�U�生成一个类型�ؓstIf的节点�ƈ弹出栈顶的exp节点填充到新生成的stIf节点的第一个子节点�?br />3.��d��then declare b as integer�Q�integer被归�U�生成一个生�c�d��为stDeclare的节点�ƈ压入语法树栈�?br />4.declare b as integer被归�U��ؓ栈顶的stDeclare节点填充一个b标识�W�的子节炏V�?br />5.then declare b as integer被归�U�，首先弹出栈顶的stmt_list因�ؓ�q�里是stDeclare说明stmt_list有内容应此将栈顶的stIf的值域的最低位�|��ؓ1�?br />6.else子句不存在�?br />7.整体被归�U��?br />此时栈顶为stIf节点�Q�其不包含next节点�Q�有两个子节点分别�ؓstExp和stDeclare�?br />
分析�q�程如下图：
1.
2.
3.
4.
5.
6.
7.

lwch 2011-07-01 21:51 发表评论

QLanguage基本语法

lwch — Mon, 27 Jun 2011 08:36:00 GMT

1.�cȝ��定义
1 class a [inherit Object]
2 end class

2.�c�M��可以包含(声明�Q�函敎ͼ�新类。其中除了class都含有public、private、protected和static属�?

1 class a
2     [public] declare a as string // 声明
3
4     [private] [static] function main() // 函数
5     end function
6
7     class b // 新类
8     end class
9 end class
3.变量声明

1 declare a as integer[,b as integer]
4.函数

1 function main([a as integer[,b as integer]])[as integer]
2 end function
5.stmt_list包含声明语句、if语句、do语句、while语句、for语句、switch语句和experience表达�?br />6.if语句

1 if experience then
2 stmt_list
3 [else stmt_list]
4 end if
7.do语句

1 do
2 stmt_list
3 while experience end
8.while语句

1 while experience do
2 stmt_list
3 end while
9.for语句

1 for stmt_list to experience by stmt_list do
2 stmt_list
3 next
10.switch语句
1 switch experience do
2 case experience:
3 [stmt_list]
4 [case experience:
5 [stmt_list]]
6 [default:
7 [stmt_list]]
8 end switch
11.experience表达�?br />
1 函数调用语句
2 赋��D��?br /> 3 symbol
4 string
5 number
6 true
7 false
8 (+|-)experience
9 not experience
10 experience (&|||^|%) experience
11 experience (>|<|>=|<=|==|!=) experience
12 experience (+|-|*|/) experience
13 ++symbol
14 --symbol
15 symbol++
16 symbol--
12.函数调用语句

1 函数�?参数�?
13.赋��D��?br />
1 变量=experience

�l�合子代�?br />
1     program = *item;
2     item = declare_desc |
3             class_desc |
4             function_desc;
5     property_desc = str_public |
6                     str_private |
7                     str_protected;
8     declare_type = str_integer |
9                     str_string |
10                     str_bool |
11                     str_real |
12                     type_symbol;
13     paramter_desc_list = (type_symbol + str_as + declare_type) +
14                         *(str_comma + type_symbol + str_as + declare_type);
15     paramter_value_list = exp_desc + *(str_comma + exp_desc);
16     declare_desc = str_declare + type_symbol + str_as + declare_type +
17         *(str_comma + type_symbol + str_as + declare_type);
18     class_desc = str_class + type_symbol +
19                 Parser_Combinator_Node::opt(str_inherit + type_symbol +
20                 *(str_comma + (type_symbol & Parser_Combinator_Node::not(str_class | str_function | property_desc | str_static)))
21                 ) + *class_content_desc + str_end + str_class;
22     class_content_desc = (Parser_Combinator_Node::opt(property_desc) + Parser_Combinator_Node::opt(str_static) +
23                         (declare_desc | function_desc)) |
24                         class_desc;
25     function_desc = (str_function + type_symbol) +
26                     (str_leftbracket + Parser_Combinator_Node::opt(paramter_desc_list) + str_rightbracket) +
27                     Parser_Combinator_Node::opt(str_as + declare_type) +
28                     stmt_list +
29                     (str_end + str_function);
30     stmt_list = *(stmt & Parser_Combinator_Node::not(str_end));
31     stmt = declare_desc |
32             if_desc |
33             do_desc |
34             while_desc |
35             for_desc |
36             switch_desc |
37             exp_desc;
38     if_desc = (str_if + exp_desc) +
39             (str_then + stmt_list) +
40             Parser_Combinator_Node::opt(str_else + stmt_list) +
41             (str_end + str_if);
42     do_desc = (str_do + stmt_list) +
43                 (str_while + exp_desc + str_end);
44     while_desc = str_while + exp_desc + str_do + stmt_list + str_end + str_while;
45     for_desc = str_for + stmt_list + str_to + exp_desc + str_by + stmt_list + str_do + stmt_list + str_next;
46     switch_desc = str_switch + exp_desc + str_do + case_list + str_end + str_switch;
47     case_list = *case_desc;
48     case_desc = (str_case + exp_desc + str_colon + stmt_list) |
49                 (str_default + str_colon + stmt_list);
50     assign_desc = type_symbol + str_equal + exp_desc;
51     call_desc = type_symbol + str_leftbracket + Parser_Combinator_Node::opt(paramter_value_list) + str_rightbracket;
52     logic_desc = (str_not + compare_desc) |
53                 (compare_desc + *((str_operator_and | str_operator_or | str_xor | str_mod) + compare_desc));
54     compare_desc = term_desc + *((str_bigger | str_smaller |
55                                 str_bigger_equal | str_smaller_equal |
56                                 str_equal_equal | str_not_equal) + term_desc);
57     term_desc = factor_desc + *((str_add | str_sub) + factor_desc);
58     factor_desc = self_desc + *((str_mul | str_div) + self_desc);
59     self_desc = (str_add_add + type_symbol) |
60                 (str_sub_sub + type_symbol) |
61                 (type_symbol + str_add_add) |
62                 (type_symbol + str_sub_sub) |
63                 value_desc;
64     value_desc = call_desc |
65                 assign_desc |
66                 type_symbol |
67                 type_string |
68                 type_number |
69                 str_true |
70                 str_false |
71                 ((str_add | str_sub) + logic_desc) |
72                 (str_leftbracket + logic_desc + str_rightbracket);
73     exp_desc = logic_desc;

如有��M��补充��会在此文档更新�?br />

lwch 2011-06-27 16:36 发表评论

ESEngine_Demo5

lwch — Wed, 02 Mar 2011 05:20:00 GMT

修正了词法分析器的一些Bug.
修正了一些运行时的Bug.
支持了单行注�?/和多行注�?* */
支持了所有的函数声明形式.

ESEngine_Demo5.rar

lwch 2011-03-02 13:20 发表评论

ESEngine_Demo4

lwch — Sun, 13 Feb 2011 11:20:00 GMT
��d��了DLL的支�?见Samples下的TestDLL.dll)

ESEngine_Demo4.rar

lwch 2011-02-13 19:20 发表评论

QLanguage

lwch — Sat, 12 Feb 2011 16:09:00 GMT
可能�q�有大量的Bug,请反馈给QQ:510134884.
QLanguage的发展需要您的支�?img border="0" align="absMiddle" src="http://www.shnenglu.com/CuteSoft_Client/CuteEditor/images/emsmile.gif" alt="" />

开源项目地址:http://qlanguage.codeplex.com/

Demo5:
修正了词法分析器的一些Bug.
修正了一些运行时的Bug.
支持了单行注�?/和多行注�?* */
支持了所有的函数声明形式.
http://www.shnenglu.com/lwch/archive/2011/03/02/140979.html

Demo4:
��d��了DLL的支�?见Samples下的TestDLL.dll)
http://www.shnenglu.com/lwch/archive/2011/02/13/139989.html

Demo3:
修正了return语句的一些Bug
��d��了COM�l��g的支�?见Samples目录下的factorial.txt)
http://www.shnenglu.com/lwch/archive/2011/02/07/139787.html

Demo2:
1.修正了函数调用时的一些Bug
2.�C�Z��中增加了一个递归求阶乘的例子
http://www.shnenglu.com/lwch/archive/2011/01/30/139624.html

Demo1:
�q�行�Ҏ��:
1.打开命��o行提�C�符
2.cd ESEngine.exe所在�\�?br /> 3.ESEngine xxx.txt 1.Samples文�g夹下有几个例�?br /> 2.函数目前只写�?br /> "function" "{Symbol}" "{LQ}" "{RQ}" stmt_list "end" "function"
"function" "{Symbol}" "{LQ}" "{RQ}" "end" "function"
"function" "{Symbol}" "{LQ}" paramter_list "{RQ}" "as" var_type stmt_list "end" "function"
�q�三�c?所以对�?br /> function mn(integer s)
stmts
end function
在生成语法树时会产生错误
http://www.shnenglu.com/lwch/archive/2011/01/28/139546.html

lwch 2011-02-13 00:09 发表评论

ESEngine_Demo3

lwch — Mon, 07 Feb 2011 09:27:00 GMT
修正了return语句的一些Bug
��d��了COM�l��g的支�?见Samples目录下的factorial.txt)

ESEngine_Demo3.rar

lwch 2011-02-07 17:27 发表评论

ESEngine_Demo2

lwch — Sun, 30 Jan 2011 13:19:00 GMT
1.修正了函数调用时的一些Bug
2.�C�Z��中增加了一个递归求阶乘的例子

ESEngine_Demo2.rar

lwch 2011-01-30 21:19 发表评论

ESEngine_Demo1

lwch — Fri, 28 Jan 2011 13:03:00 GMT

�q�行�Ҏ��:
1.打开命��o行提�C�符
2.cd ESEngine.exe所在�\�?br>3.ESEngine xxx.txt

1.Samples文�g夹下有几个例�?br>2.函数目前只写�?br> "function" "{Symbol}" "{LQ}" "{RQ}" stmt_list "end" "function"
"function" "{Symbol}" "{LQ}" "{RQ}" "end" "function"
"function" "{Symbol}" "{LQ}" paramter_list "{RQ}" "as" var_type stmt_list "end" "function"
�q�三�c?所以对�?br> function mn(integer s)
stmts
end function
在生成语法树时会产生错误

 ESEngine_Demo1_0.rar

lwch 2011-01-28 21:03 发表评论

lwch — Thu, 27 Jan 2011 13:39:00 GMT
表达�?

1 function main()
2     integer a
3     a = -(-a + -123 * +5 + -a)
4 end function

��译�l�果:

表达�?

1 function main()
2     integer a
3     a = -(-a - -1)
4 end function

��译�l�果:

lwch 2011-01-27 21:39 发表评论

ATL调用COM�cȝ��装

lwch — Sat, 20 Nov 2010 14:40:00 GMT
COM.h:

1 #pragma once
2 #include <atlcomcli.h>
3
4 class COMMacro
5 {
6 public:
7     COMMacro(LPTSTR Object);
8     ~COMMacro();
9     BOOL Invoke(LPTSTR strFunction,VARIANT* pVarParams,int nParamterCount,VARIANT* pResult);
10     VARIANT ToVARIANT(BSTR str);
11     VARIANT ToVARIANT(int nVal);
12     VARIANT ToVARIANT(bool bVal);
13     VARIANT ToVARIANT(double dVal);
14     VARIANT ToVARIANT_ByRef(BSTR* pStr);
15     VARIANT ToVARIANT_ByRef(int* pnVal);
16     VARIANT ToVARIANT_ByRef(bool* pbVal);
17     VARIANT ToVARIANT_ByRef(double* pdVal);
18     BSTR ToBSTR(VARIANT Val);
19     int ToInt(VARIANT Val);
20     bool ToBool(VARIANT Val);
21     double ToDouble(VARIANT Val);
22
23     BOOL ToBSTR(LPTSTR src,BSTR& dest);
24 protected:
25     CLSID m_clsID;
26     CComPtr<IUnknown> m_Unknown;
27     CComDispatchDriver* m_pDispatchDriver;
28 };
COM.cpp:

  1 #include "stdafx.h"
  2 #include "COM.h"
  3 #include <comdef.h>
  4
  5 COMMacro::COMMacro(LPTSTR Object)
  6 {
  7     HRESULT hr = CLSIDFromProgID(Object,&m_clsID);
  8     if(FAILED(hr))
  9     {
10         throw _com_error(hr);
11         return;
12     }
13     hr = CoCreateInstance(m_clsID,NULL,CLSCTX_ALL,IID_IUnknown,(LPVOID*)&m_Unknown);
14     if(FAILED(hr))
15     {
16         throw _com_error(hr);
17         return;
18     }
19     m_pDispatchDriver = new CComDispatchDriver(m_Unknown);
20 }
21
22 COMMacro::~COMMacro()
23 {
24     delete m_pDispatchDriver;
25 }
26
27 BOOL COMMacro::Invoke(LPTSTR strFunction,VARIANT* pVarParams,int nParamterCount,VARIANT* pResult)
28 {
29     DISPID DispID;
30     HRESULT hr = m_pDispatchDriver->GetIDOfName(strFunction,&DispID);
31     if(FAILED(hr))
32     {
33         throw _com_error(hr);
34         return FALSE;
35     }
36     hr = m_pDispatchDriver->InvokeN(DispID,pVarParams,nParamterCount,pResult);
37     if(FAILED(hr))
38     {
39         throw _com_error(hr);
40         return FALSE;
41     }
42     return TRUE;
43 }
44
45 VARIANT COMMacro::ToVARIANT(BSTR str)
46 {
47     VARIANT vResult;
48     vResult.vt = VT_BSTR;
49     vResult.bstrVal = SysAllocString(str);
50     return vResult;
51 }
52
53 VARIANT COMMacro::ToVARIANT(int nVal)
54 {
55     VARIANT vResult;
56     vResult.vt = VT_I4;
57     vResult.intVal = nVal;
58     return vResult;
59 }
60
61 VARIANT COMMacro::ToVARIANT(bool bVal)
62 {
63     VARIANT vResult;
64     vResult.vt = VT_BOOL;
65     vResult.boolVal = bVal;
66     return vResult;
67 }
68
69 VARIANT COMMacro::ToVARIANT(double dVal)
70 {
71     VARIANT vResult;
72     vResult.vt = VT_R8;
73     vResult.dblVal = dVal;
74     return vResult;
75 }
76
77 VARIANT COMMacro::ToVARIANT_ByRef(BSTR* pStr)
78 {
79     VARIANT vResult;
80     vResult.vt = VT_BSTR | VT_BYREF;
81     vResult.byref = pStr;
82     return vResult;
83 }
84
85 VARIANT COMMacro::ToVARIANT_ByRef(int* pnVal)
86 {
87     VARIANT vResult;
88     vResult.vt = VT_I4 | VT_BYREF;
89     vResult.byref = pnVal;
90     return vResult;
91 }
92
93 VARIANT COMMacro::ToVARIANT_ByRef(bool* pbVal)
94 {
95     VARIANT vResult;
96     vResult.vt = VT_BOOL | VT_BYREF;
97     vResult.byref = pbVal;
98     return vResult;
99 }
100
101 VARIANT COMMacro::ToVARIANT_ByRef(double* pdVal)
102 {
103     VARIANT vResult;
104     vResult.vt = VT_BOOL | VT_BYREF;
105     vResult.byref = pdVal;
106     return vResult;
107 }
108
109 BSTR COMMacro::ToBSTR(VARIANT Val)
110 {
111     return *(BSTR*)Val.byref;
112 }
113
114 int COMMacro::ToInt(VARIANT Val)
115 {
116     return *(int*)Val.byref;
117 }
118
119 bool COMMacro::ToBool(VARIANT Val)
120 {
121     return *(bool*)Val.byref;
122 }
123
124 double COMMacro::ToDouble(VARIANT Val)
125 {
126     return *(double*)Val.byref;
127 }
128
129 BOOL COMMacro::ToBSTR(LPTSTR src,BSTR& dest)
130 {
131     dest = SysAllocString(src);
132     return TRUE;
133 }

使用说明:
1.构造函�?
参数(字符串常�?:工程�?�c�d��
2.Invoke:
参数1(字符串常�?:函数�?br>参数2(VARIANT数组):调用参数,从右臛_��
参数3(数值常�?:调用参数个数
参数4(VARIANT指针):�q�回�?br>3.ToVARIANT:��给定参数�{换�ؓVARIANT�c�d��
4.ToVARIANT_ByRef:��给定参数�{换�ؓByRef的VARIANT�c�d��
5.ToBSTR:��给定ByRef的VARIANT转换为BSTR
6.ToInt:��给定ByRef的VARIANT转换为int
7.ToBool:��给定ByRef的VARIANT转换为bool
8.ToDouble:��给定ByRef的VARIANT转换为double
9.ToBSTR:��给定字�W�串帔R��转换为BSTR�c�d��

�C�Z��:

1     CoInitialize(0); // 初始化ATL
2     try
3     {
4         COMMacro m(L"aaa.bbb");
5         VARIANT vResult,vParams[3];
6         int i = 100;
7         BSTR str;
8         m.ToBSTR(L"abc",str);
9         vParams[2] = m.ToVARIANT(123.456);
10         vParams[1] = m.ToVARIANT(i);
11         vParams[0] = m.ToVARIANT_ByRef(&str);
12         m.Invoke(L"aaa",vParams,3,&vResult);
13         wprintf(L"%s\n",m.ToBSTR(vParams[0]));
14     }
15     catch(_com_error& e)
16     {
17         wprintf(L"%s\n",e.ErrorMessage());
18     }

lwch 2010-11-20 22:40 发表评论

lwch — Sat, 02 Oct 2010 03:56:00 GMT
代码:

1 function fact(integer n) as integer
2     if n > 1 then
3         return fact(n - 1) * n
4     else
5         return n
6     end if
7 end function
8
9 function main()
10     integer Result
11     Result = fact(5)
12 end function
�W�号�?

0    n
1    1
2    fact
3    Result
4    5
5    main
��译�l�果:

lwch 2010-10-02 11:56 发表评论

lwch — Wed, 29 Sep 2010 07:55:00 GMT
首先生成抽象语法�?�Ҏ��如下:
1.根节点�ؓ0时表�C�没有default标签,�?时表�C�有default标签
2.�W?个根节点表示switch里的条�g
3.若有default标签,则最后一个根节点为default子树
4.每个根节点�ؓ0时表�C�在此标�{�下没有stmt_list语句�?�q�个节点的唯一孩子��匚w��的表辑ּ�;�?时表�C�有语句�?根节点的左孩子表�C��匚w��的表辑ּ�,叛_��子�ؓ要执行的语句�?br>注意:Equal指��o会弹��Z��操作�?应此在Equal指��o执行之前必须先保留switch里exp的副�?即Push一��?,最后弹出副�?br>��试代码:

1 integer aaa,bbb
2
3 function ccc()
4     switch aaa + 1 do
5         default:
6             aaa = 123
7         case 123:
8             do
9                 aaa = aaa + 1
10             while aaa < 789 end
11         case 456:
12             aaa = 123
13     end switch
14 end function
生成虚拟��Z��?

lwch 2010-09-29 15:55 发表评论

lwch — Wed, 22 Sep 2010 04:20:00 GMT
For语句的翻译比较复�?�?个前�|�条件和�q�行代码,1个语句块,也就�?*3*2*1=24�U�情�?应此在生成抽象语法树的时候我采用的是2�q�制位来表示当前块是否存�?其中最底位表示stmt_list语句�?倒数�W?位表�C�by之后的语句是否存�?倒数�W?位表�C�to之后的表辑ּ�是否存在,倒数�W?位表�C�for之后的语句是否存�?
代码:
1 integer aaa,bbb
2
3 function ccc()
4     do
5         for aaa = 456 to by do
6             if aaa == 456 then
7                 aaa = 789
8             end if
9         next
10         aaa = 123
11     while aaa == 123 end
12 end function
��译�l�果:

lwch 2010-09-22 12:20 发表评论

lwch — Mon, 20 Sep 2010 14:29:00 GMT
已实现do,while,if和赋��D��句的语法制导��译,�q�次��他们逐层嵌套��h��看看��译�l�果是否正确.
代码:

1 integer aaa
2
3 function ccc()
4     while aaa == 123 do
5         do
6             if aaa == 123 then
7                 if aaa == 456 then aaa = 123
8                 else aaa = 456
9                 end if
10             end if
11         while aaa == 123 end
12     end while
13     aaa = 456
14 end function
��译�l�果:

lwch 2010-09-20 22:29 发表评论

lwch — Sat, 18 Sep 2010 23:27:00 GMT

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5     end if
6 end function

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5         aaa = 123
6     end if
7 end function

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5     else
6     end if
7 end function

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5         aaa = 123
6     else
7     end if
8 end function

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5     else
6         aaa = 123
7     end if
8 end function

1 integer aaa
2
3 function ccc()
4     if aaa and true then
5         aaa = 123
6     else
7         aaa = 456
8     end if
9 end function

lwch 2010-09-19 07:27 发表评论

ESLanguage部分语法制导��译

lwch — Fri, 17 Sep 2010 14:21:00 GMT
首先生成抽象语法�?AST)
生成�Ҏ��:
1.�U�进时将Number,String或Symbol分别加入对应集合
2.归约时从集合中取出对应的成员,�q�删除这条��生式里的所有终�l�符
3.��生的语法树节点压入栈�?br>4.当遇��C�生式item_list->item_list item或stmt_list->stmt_list stmt时从栈中弹出两颗语法树�ƈ按顺序连接�v�?br>5.当遇到非�l�结�W�时弹出相应数量的语法树节点,生成新的根节点�ƈ把弹出的语法树节炚w��q�接到这个新的根节点�?br>6.当归�U�到�W?条��生式时检查栈的元素数�?1为正常�?然后�Ҏ��象语法树�q�行前序遍历�q�生成虚拟机代码

lwch 2010-09-17 22:21 发表评论

ESLanguage部分语法

lwch — Fri, 17 Sep 2010 14:04:00 GMT
     摘要:   1 %token "function" "as" "end";  2 %token "integer" "string" "bool" "pointer";  3 %token "if" "then" "e...  阅读全文

lwch 2010-09-17 22:04 发表评论

亚久久调教视频,91久久精品国产91性色,欧美丝袜一区二区

QParserGenerator代码分析�?A fix&An example)

QParserGenerator代码分析一(生成LALR1 DFA)

词法分析�?(ε-NFA到DFA的�{�?

DFA的边

ε闭包

���֣�

词法分析�?(正则表达式到ε-NFA的�{�?

自动�?/h1> 关于自动机的说明�Q�这里不不再复述�Q�请�?a href="http://zh.wikipedia.org/wiki/自动�? target="_blank">http://zh.wikipedia.org/wiki/自动�?/a>查看�?/p>

表达�?/h1> 首先�Q�我们规定表辑ּ�中只允许输入Char_Type和String_Type�c�d��的字�W��?/p> template class Rule { };

ε-NFA的边

生成状态机

串联关系

�q�联关系

重复关系

一些拓�?/h1> 下面来看看一些拓展�Ş式的状态机是如何生成的�?/p>

取反关系

Char-Char关系

���֣�

修复了一个关于CParser_Input的Bug

QLanguage的AST

QLanguage基本语法

ESEngine_Demo5

ESEngine_Demo4

QLanguage

ESEngine_Demo3

ESEngine_Demo2

ESEngine_Demo1

ATL调用COM�cȝ�����装

ESLanguage部分语法制导���译

ESLanguage部分语法

��֣�

自动�?/h1>
关于自动机的说明�Q�这里不不再复述�Q�请�?a href="http://zh.wikipedia.org/wiki/自动�? target="_blank">http://zh.wikipedia.org/wiki/自动�?/a>查看�?/p>

表达�?/h1>
首先�Q�我们规定表辑ּ�中只允许输入Char_Type和String_Type�c�d��的字�W��?/p>

template class Rule { };

一些拓�?/h1>
下面来看看一些拓展�Ş式的状态机是如何生成的�?/p>

��֣�

ATL调用COM�cȝ��装

ESLanguage部分语法制导��译