C++博客-lwch-随笔分类-NScript

使用内联汇编动态调用DLL

lwch — Sun, 06 Feb 2011 14:21:00 GMT

1.首先我们必须知道C语言的调用约定为__cdecl(即参数从右向左依次进栈,由调用者还原堆栈).
2.一条push指令最多压入4个字节,当不足4个字节时应补齐4个字节,超过4个字节时应该由低位到高位依次压栈.
3.pop指令也和push一样一次只能弹出4个字节.
4.我们需要一个CallStruct类型来储存一个参数.

1 class CallStruct
2     {
3     public:
4         INT            Integer;
5         BOOL        Bool;
6         DOUBLE        Real;
7         WCHAR        String[MAX_STRING];
8
9         enum TYPE
10         {
11             ctInteger,
12             ctString,
13             ctBool,
14             ctReal,
15             ctVoid,
16         }Type;
17
18         CallStruct() : Integer(0),Bool(FALSE),Real(0)
19         {
20             String[0]    = 0;
21         }
22
23         CallStruct(const NAutoPtr<VirtualMachine::VarClass>& Var) : Integer(Var->Integer),Bool(Var->Bool),Real(Var->Real),Type((TYPE)Var->Type)
24         {
25             if(Type == ctString) wcscpy(String,Var->String);
26         }
27     };

5.我们需要一个列表来存放参数和一个返回值对象来存放返回值.

1 List<NAutoPtr<CallStruct>> VarList;
2 NAutoPtr<CallStruct> Return;

6.最后我们需要一个HMODULE和一个FARPROC分别存放dll的句柄和函数地址.

1 HMODULE hModule;
2 FARPROC FunctionPtr;

7.然后我们添加几个功能函数.

1     BOOL AddVar(NAutoPtr<VirtualMachine::VarClass>& Var);
2     BOOL SetReturnType(CallStruct::TYPE Type);
3     BOOL SetLibName(LPTSTR Name);
4     BOOL SetFunctionName(LPTSTR Name);

注意:GetProcAddress第二个参数只接受LPCSTR类型的字符串,应此如果传入的是Unicode编码的字符必须将其转换成ANSI的.
8.我们添加一个函数Run用于调用函数.

1 BOOL CallMacro::Run()
2 {
3     if(FunctionPtr == 0 || Return.Buffer() == 0) return FALSE;
4     union RealStruct
5     {
6         double Real;
7         struct
8         {
9             int Head,Tail;
10         };
11     };
12     NAutoPtr<CallStruct> cs;
13     int Integer;
14     BOOL Bool;
15     RealStruct Real; // Push指令一次只能压入4字节
16     LPTSTR String;
17
18     int iEsp;
19     __asm mov int ptr[iEsp],esp; // 保存esp
20     for(int i=0;i<VarList.Size();i++)
21     {
22         cs = VarList[i];
23         Integer = cs->Integer;
24         Bool = cs->Bool;
25         Real.Real = cs->Real;
26         String = cs->String;
27         switch(cs->Type)
28         {
29         case CallStruct::ctInteger:
30             __asm push Integer;
31             break;
32         case CallStruct::ctString:
33             __asm push String;
34             break;
35         case CallStruct::ctBool:
36             __asm push Bool;
37             break;
38         case CallStruct::ctReal:
39             __asm push Real.Tail;
40             __asm push Real.Head;
41             break;
42         }
43     }
44     FARPROC proc = FunctionPtr;
45     int Head,Tail;
46     __asm
47     {
48         call proc
49         mov int ptr[Head],edx
50         mov int ptr[Tail],eax
51     }
52     switch(Return->Type)
53     {
54     case CallStruct::ctInteger:
55         Return->Integer = Tail;
56         break;
57     case CallStruct::ctString:
58         wcscpy(Return->String,(LPCTSTR)Tail);
59         break;
60     case CallStruct::ctBool:
61         Return->Bool = Tail;
62         break;
63     case CallStruct::ctReal:
64         __asm fstp [Real.Real];
65         Return->Real = Real.Real;
66         break;
67     }
68     // __declspec调用约定,需要手工还原堆栈
69     __asm mov esp,int ptr[iEsp];
70     return TRUE;
71 }

Run函数首先检查是否已经装载了DLL并获得了函数地址,以及返回值类型是否已经定义.
然后根据类型依次将函数压栈.
然后调用call指令并保存返回值.(这里需要注意的是当返回值类型为double或float类型时必须使用fstp指令从FPU寄存器栈的栈顶的值取出来)
最后还原堆栈.

然后我们来测试一下.
创建一个名为TestDLL的DLL工程并添加函数Test.

1 TESTDLL_API double Test(double d,double* d1,WCHAR* lpBuffer)
2 {
3     if(d == 123.456789) MessageBox(0,lpBuffer,L"",0);
4     *d1 = 789.654;
5     return 77777;
6 }

然后创建一个测试工程,添加相关文件.
在_tmain中添加以下代码.

1 int _tmain(int argc, _TCHAR* argv[])
2 {
3     double d;
4     CallMacro cm;
5     NAutoPtr<VirtualMachine::VarClass> Var;
6
7     Var = new VirtualMachine::VarClass;
8     Var->Type = VirtualMachine::VarClass::vtString;
9     wcscpy(Var->String,L"aaaaa");
10     cm.AddVar(Var);
11
12     Var = new VirtualMachine::VarClass;
13     Var->Type = VirtualMachine::VarClass::vtInteger;
14     Var->Integer = (INT)&d;
15     cm.AddVar(Var);
16
17     Var = new VirtualMachine::VarClass;
18     Var->Type = VirtualMachine::VarClass::vtReal;
19     Var->Real = 123.456789;
20     cm.AddVar(Var);
21
22     cm.SetLibName(L"TestDll.dll");
23     cm.SetFunctionName(L"Test");
24     cm.SetReturnType(CallMacro::CallStruct::ctReal);
25     cm.Run();
26
27     wprintf(L"%f %f\n",d,cm.Return->Real);
28     system("pause");
29     return 0;
30 }

编译并运行,可以看到Test函数调用成功,并成功输出d的值和返回值.

最后给出完整代码.

lwch 2011-02-06 22:21 发表评论

使用面向组合子算法写词法分析器

lwch — Wed, 26 Jan 2011 14:11:00 GMT

继《面向组合子的一些测试》进一步完善代码,制作出词法分析器.

我们首先需要一个Fail基类,他有一个纯虚函数Parser.

1 class Fail
2 {
3 public:
4 virtual NWString Parser(NWString& input)=0;
5 };

Parser的输入为要分析的字符串,输出为分析完成后剩余的字符串.

然后我们需要一个Ch和一个Str分别用来分析单个字符和一个字符串.

1 class Ch : public Fail
2 {
3 public:
4     Ch(WCHAR _value) : value(_value){}
5
6     NWString Parser(NWString& input);
7
8     WCHAR Value();
9 protected:
10     WCHAR value; // 待匹配串
11 };
12
13 class Str : public Fail
14 {
15 public:
16     Str(NWString _value) : value(_value){}
17
18     NWString Parser(NWString& input);
19 protected:
20     NWString value; // 待匹配串
21 };

然后是Seq,Alt和Any,分别表示组合,选择和循环.

1 class Seq : public Fail
2 {
3 public:
4     Seq(const NAutoPtr<Fail>& _left,const NAutoPtr<Fail>& _right) : left(_left),right(_right){}
5
6     NWString Parser(NWString& input);
7 protected:
8     NAutoPtr<Fail> left;
9     NAutoPtr<Fail> right;
10 };
11
12 class Alt : public Fail
13 {
14 public:
15     Alt(const NAutoPtr<Fail>& _left,const NAutoPtr<Fail>& _right) : left(_left),right(_right){}
16
17     NWString Parser(NWString& input);
18 protected:
19     NAutoPtr<Fail> left;
20     NAutoPtr<Fail> right;
21 };
22
23 class Any : public Fail
24 {
25 public:
26     Any(const NAutoPtr<Fail>& _left,const int _count) : left(_left),count(_count){}
27
28     NWString Parser(NWString& input);
29 protected:
30     NAutoPtr<Fail> left;
31     int count;
32 };

最后我们需要一个Node类型来存放以上这几类对象.

1 class Node
2 {
3 public:
4     Node(){}
5     Node(const NAutoPtr<Fail>& _left) : left(_left){}
6
7     friend NAutoPtr<Node> operator+(const NAutoPtr<Node>& left,const NAutoPtr<Node>& right);
8     friend NAutoPtr<Node> operator|(const NAutoPtr<Node>& left,const NAutoPtr<Node>& right);
9     friend NAutoPtr<Node> operator-(const NAutoPtr<Node>& left,const NAutoPtr<Node>& right);
10
11     static NAutoPtr<Node> OnceMore(NAutoPtr<Node> node);
12     static NAutoPtr<Node> More(NAutoPtr<Node> node);
13     static NAutoPtr<Node> NewCh(WCHAR input);
14     static NAutoPtr<Node> NewStr(NWString input);
15
16     NWString Parser(NWString& input);
17
18     NAutoPtr<Fail>& Value();
19 protected:
20     NAutoPtr<Fail> left;
21 };

下面来分析一下Node里的函数:
+:对应于Seq,用于将两个Node连接起来.
|:对应与Alt,用于选择两个Node.
-:只有left和right的Value()都是NAutoPtr时才可使用,内部有类型转换,表示从哪个字符到哪个字符.
OnceMore:重复1次及以上.
More:重复0次以上.
NewCh:生成一个NAutoPtr的Node对象.
NewStr:生成一个NAutoPtr的Node对象.

下面我们需要4个宏.

1 #define ONCEMORE(N)                    Node::OnceMore(N)
2 #define MORE(N)                        Node::More(N)
3 #define NEWCH(N)                    Node::NewCh(N)
4 #define NEWSTR(N)                    Node::NewStr(N)

这4个宏仅为了输入方便

然后我们来测试一下:

1     NAutoPtr<Node> Symbol = ONCEMORE(NEWCH('_') | NEWCH('a') - NEWCH('z')) | (NEWCH('A') - NEWCH('Z'))
2         + MORE(NEWCH('_') | (NEWCH('0') - NEWCH('9')) | (NEWCH('a') - NEWCH('z')) | (NEWCH('A') - NEWCH('Z')));
3     NAutoPtr<Node> Number = ONCEMORE(NEWCH('0') - NEWCH('9'));
4     NAutoPtr<Node> Real = Number + NEWCH('.') + Number;

相信对正则表达式有一定认识的同学已经知道这3条语句分别对应于什么正则表达式.
Symbol->[_a-zA-Z]+[_0-9a-zA-Z]*
Number->[0-9]+
Real->[0-9]+.[0-9]+

定义一个待分析的字符串.

1 NWString str = L"abcce_fg123.459agetr";

对其分析.

1     wprintf(L"%s\n",str);
2     wprintf(L"%s\n",Symbol->Parser(str));
3     wprintf(L"%s\n",Real->Parser(str));
4     wprintf(L"%s\n",Symbol->Parser(str));

分析结果.

1 abcce_fg123.459agetr
2 123.459agetr
3 agetr
4

因为没有考虑分析效率问题,所以使用NWString作为输入和输出,在实际使用中可用LPTSTR来代替NWString,同时修改响应代码.
最后给出源代码

lwch 2011-01-26 22:11 发表评论

面向组合子的一些测试

lwch — Sat, 22 Jan 2011 09:11:00 GMT

摘要: 本文的思路来源于http://www.cppblog.com/vczh/archive/2008/05/21/50656.html首先先看代码: 1 #include 2 3 class Element 4 {&n... 阅读全文

lwch 2011-01-22 17:11 发表评论

NScript部分数据结构

lwch — Fri, 14 Jan 2011 08:00:00 GMT

下面来分析一下NScript的部分数据结构

1     class SyntaxNode
2     {
3     public:
4         int Op1;
5         int Op2;
6         List<NAutoPtr<SyntaxNode>> Child;
7
8         SyntaxNode(int O1,int O2) : Op1(O1),Op2(O2){}
9     };
10
11     class CharClass
12     {
13     public:
14         int Index;
15         NWString String;
16
17         CharClass(NWString S) : String(S){}
18     };

每个语法树的节点有2个参数Op1,Op2分别表示当前节点的类型和附加参数
Child为当前节点的子节点

CharClass结构则比较简单分别为索引和字符

然后是部分SyntaxNode的Op1的枚举:

1     enum OpCode_Type
2     {
3         opNull,
4         opVar,
5         opConst,
6     };

以及VarType的枚举:

1     enum Var_Type
2     {
3         vtNull,
4         vtVoid,
5         vtBool,
6         vtInt,
7         vtReal,
8         vtString,
9         vtSymbol,
10     };

和产生式索引的宏定义:

1     #define INDEX_VARTYPE_VOID                1
2     #define INDEX_VARTYPE_BOOL                2
3     #define INDEX_VARTYPE_INT                3
4     #define INDEX_VARTYPE_REAL                4
5     #define INDEX_VARTYPE_STRING            5
6     #define INDEX_VALUETYPE_STRING            6
7     #define INDEX_VALUETYPE_SYMBOL            7
8     #define INDEX_VALUETYPE_REAL            8
9     #define INDEX_VALUETYPE_DIGIT            9
10     #define INDEX_VALUETYPE_TRUE            10
11     #define INDEX_VALUETYPE_FALSE            11

以上索引的定义取自NS.txt,随着以后文法的增加这里的索引定义也会增加
NS.h,NS.cpp,NS.ParserTable均是由NScriptMacro.exe运行NS.txt生成的

下面来看一下SyntaxAnalyze函数:

1 BOOL NSyntax::SyntaxAnalyze(int i)
2 {
3     BOOL bResult = TRUE;
4     // 根据产生式索引生成语法树
5     switch(i)
6     {
7     case INDEX_VARTYPE_VOID:
8     case INDEX_VARTYPE_BOOL:
9     case INDEX_VARTYPE_INT:
10     case INDEX_VARTYPE_REAL:
11     case INDEX_VARTYPE_STRING:
12         bResult = VarType(i);
13         break;
14     case INDEX_VALUETYPE_STRING:
15     case INDEX_VALUETYPE_SYMBOL:
16     case INDEX_VALUETYPE_REAL:
17     case INDEX_VALUETYPE_DIGIT:
18     case INDEX_VALUETYPE_TRUE:
19     case INDEX_VALUETYPE_FALSE:
20         bResult = ValueType(i);
21         break;
22     }
23     return bResult;
24 }

这个函数根据传入参数(产生式索引)调用相关函数生成语法树,具体语法树的生成过程请看相关代码

lwch 2011-01-14 16:00 发表评论

开源编译器项目NScript

lwch — Thu, 13 Jan 2011 13:38:00 GMT

项目地址

最初文法定义为:

1 %token "void" "bool" "int" "real" "string";
2 %token "true" "false";
3 %token "{" "}" "," ";" "=";
4 %token "+" "-" "*" "/";
5 %token ">" "<" ">=" "<=" "==" "and" "not" "or";
6
7 %start program;
8
9 var_type    ->    "void"
10             |    "bool"
11             |    "int"
12             |    "real"
13             |    "string"
14             ;
15
16 value_type    ->    "{String}"
17             |    "{Symbol}"
18             |    "{real}"
19             |    "{digit}"
20             |    "true"
21             |    "false"
22             ;
23
24 paramter_define_desc    ->    "{LQ}" paramter_defines "{RQ}"
25                         |    "{LQ}" "{RQ}"
26                         ;
27
28 paramter_defines    ->    paramter_defines "," paramter_one
29                     |    paramter_one
30                     ;
31
32 paramter_one        ->    var_type "{Symbol}"
33                     ;
34
35 assign_type            ->    "{Symbol}"
36                     ;
37
38 program        ->    item_list
39             ;
40
41 item_list    ->    item_list item
42             |    item
43             ;
44
45 item        ->    function
46             |    define_desc ";"
47             ;
48
49 stmt_list    ->    stmt_list stmt
50             |    stmt
51             ;
52
53 stmt        ->    define_desc ";"
54             |    assign_desc ";"
55             |    ";"
56             ;
57
58 function    ->    var_type "{Symbol}" paramter_define_desc "{" stmt_list "}"
59             |    var_type "{Symbol}" paramter_define_desc "{" "}"
60             ;
61
62 define_desc    ->    define_desc "," "{Symbol}"
63             |    var_type "{Symbol}"
64             ;
65
66 assign_desc    ->    assign_type "=" exp
67             ;
68
69 exp        ->    exp ">" exp1
70         |    exp "<" exp1
71         |    exp ">=" exp1
72         |    exp "<=" exp1
73         |    exp "==" exp1
74         |    exp "and" exp1
75         |    exp "or" exp1
76         |    "not" exp1
77         |    "+" exp1
78         |    "-" exp1
79         |    exp1
80         ;
81
82 exp1        ->    exp1 "+" exp2
83         |    exp1 "-" exp2
84         |    exp2
85         ;
86
87 exp2        ->    exp2 "*" exp3
88         |    exp2 "/" exp3
89         |    exp3
90         ;
91
92 exp3        ->    "{LQ}" exp "{RQ}"
93         |    value_type
94         ;

由以上文法中仅有函数的定义和变量的定义
有点类C的味道.
已成功将ESLanguage大部分代码移植到这个项目里.

lwch 2011-01-13 21:38 发表评论

已完成语法分析器

lwch — Mon, 30 Aug 2010 09:29:00 GMT

分析器文法:

1 %token    "%token" "%start"                ;
2 %token    ";" "->" "|"                    ;
3
4 %start program                        ;
5
6 program        ->    item_list
7         ;
8
9 item_list    ->    item_list item
10         |    item
11         ;
12
13 item        ->    token_def ";"
14         |    start_def ";"
15         |    rule_def ";"
16         |    ";"
17         ;
18
19 token_def    ->    token_def "{String}"
20         |    "%token" "{String}"
21         ;
22
23 start_def    ->    "%start" "{Symbol}"
24         ;
25
26 rule_def    ->    "{Symbol}" "->" rhs_list
27         ;
28
29 rhs_list    ->    rhs_list "|" rhs
30         |    rhs
31         ;
32
33 rhs        ->    rhs "{String}"
34         |    rhs "{Symbol}"
35         |    "{String}"
36         |    "{Symbol}"
37         ;
38

NScriptMacro
主要用来将给定的文法文件转化为LALR(1)分析表,生成的cpp和h文件可使用分析器分析,out文件是语法分析表
里面有个简单的CMinus的例子

lwch 2010-08-30 17:29 发表评论

已实现分析器自动生成分析表

lwch — Sat, 28 Aug 2010 07:28:00 GMT

对于给定文法文件:

1 %token "if" "then" "else" "end" ;
2 %token "st" ;
3 %token "+" "*" ;
4
5 %start program ;
6
7 program        ->    if_stmt
8         ;
9
10 if_stmt        ->    "if" exp "then" stmt "end"
11         |    "if" exp "then" stmt "else" stmt "end"
12         ;
13
14 exp        ->    exp1
15         ;
16
17 exp1        ->    exp1 "+" exp2
18         |    exp2
19         ;
20
21 exp2        ->    exp2 "*" exp3
22         |    exp3
23         ;
24
25 exp3        ->    "{LQ}" exp1 "{RQ}"
26         |    "{digit}"
27         ;
28
29 stmt        ->    "st"
30         ;

生成分析表得:

lwch 2010-08-28 15:28 发表评论

修改分析器的分析器的语法

lwch — Sat, 28 Aug 2010 07:23:00 GMT

去除了letter定义,暂时还不支持正则表达式..

lwch 2010-08-28 15:23 发表评论

我的语法分析器的分析器的基本语法和分析表

lwch — Tue, 03 Aug 2010 12:21:00 GMT

基本语法:

1 %token    "%token" "%letter" "%start"            ;
2 %token    ":" ";" "->" "|"                ;
3
4 %letter string    :    "{string}"            ;
5 %letter symbol    :    "{symbol}"            ;
6
7 %start program                        ;
8
9 string_list    ->    string_list string
10         |    string
11         ;
12
13 symbol_list    ->    symbol_list symbol
14         |    symbol
15         ;
16
17 program        ->    item_list
18         ;
19
20 item_list    ->    item_list item
21         |    item
22         ;
23
24 item        ->    token_def ";"
25         |    letter_def ";"
26         |    start_def ";"
27         |    rule_def ";"
28         |    ";"
29         ;
30
31 token_def    ->    "%token" string_list
32         ;
33
34 letter_def    ->    "%letter" symbol ":" string_list
35         ;
36
37 start_def    ->    "%start" symbol
38         ;
39
40 rule_def    ->    symbol "->" rhs_list
41         ;
42
43 rhs_list    ->    rhs_list "|" rhs
44         |    rhs
45         ;
46
47 rhs        ->    term_list
48         ;
49
50 term_list    ->    term_list string
51         |    term_list symbol
52         |    string
53         |    symbol
54         ;

生成的分析表:
由于状态数量和非终结符数量过多,所以给出文件《分析表》

下面是四则混合运算的文法文件:

1 %token "+" "-"                ;
2 %token "*" "/"                ;
3 %token "(" ")"                ;
4
5 %letter AddOp    :    "+" "-"        ;
6 %letter MulOp    :    "*" "/"        ;
7 %letter ID    :    "{digit}"    ;
8 %letter LQ    :    "("        ;
9 %letter RQ    :    ")"        ;
10
11 %start Program                ;
12
13 Program        ->    Exp
14         ;
15
16 Exp        ->    Exp AddOp Term
17         |    Term
18         ;
19
20 Term        ->    Term MulOp Factor
21         |    Factor
22         ;
23
24 Factor        ->    LQ Exp RQ
25         |    ID
26         ;

lwch 2010-08-03 20:21 发表评论

已实现从语法树到四元码的生成

lwch — Sat, 31 Jul 2010 17:05:00 GMT

对于给定表达式:
123 * 567 + 456 * (789 + 456)
生成四元码得:

对于表达式:
123 + 456 * (789 + 456) / 123 + 789
生成四元码得:

lwch 2010-08-01 01:05 发表评论

已实现一个四则混合运算分析器

lwch — Mon, 26 Jul 2010 03:41:00 GMT

对于式子:10 + (5 + 9) / 3 - 7 * 3
求解过程如下:

主要在规约过程中增加了调用相关语义处理函数来实现计算.

lwch 2010-07-26 11:41 发表评论

四则混合运算分析表

lwch — Sat, 24 Jul 2010 15:35:00 GMT

lwch 2010-07-24 23:35 发表评论

Precept和NV类的封装

lwch — Thu, 22 Jul 2010 15:23:00 GMT

摘要: 1 #pragma once 2 #include "..\String\NWString.h" 3 #include "..\AutoPtr\AutoPtr.h" 4 #include "..\Common\List.h"&nb... 阅读全文

lwch 2010-07-22 23:23 发表评论

LALR(1)对于冲突的解决方案

lwch — Thu, 22 Jul 2010 07:04:00 GMT

1.对于典型的if-else二义性文法,存在移进-接受(移进-归约)冲突,在我的LALR分析器中采用了和YACC相同的方法,首先处理移进操作.这样就可消除if-else的二义性.
if-else文法:
S->iEStS
S->iES
S->s
E->e
说明:
i代表if
s代表stmt
e代表exp
t代表else
对于以上文法生成的LALR(1)分析表为:

对于if exp stmt语句分析结果为:

对于if exp stmt else stmt语句分析结果为:

对于if exp if exp stmt语句分析结果为:

对于if exp if exp stmt else stmt语句分析结果为:

2.众所周知LALR文法同样存在归约-归约冲突,在我的LALR分析器中使用先书写的产生式进行归约.
对于给定的存在归约-归约冲突的文法:
S->T
S->i
T->i

生成LALR(1)分析表为:

分析输入串i的过程为:

以上就是我的LALR(1)分析器处理冲突的方法了.
下面逐步对这个分析器进行扩充,以实现一个能自由输入文法的分析器.

lwch 2010-07-22 15:04 发表评论

已实现LALR(1)分析器

lwch — Wed, 21 Jul 2010 12:24:00 GMT

对于给定文法:
E->E+T
E->E-T
E->T
T->T*F
T->T/F
T->F
F->(E)
F->i
生成LALR(1)分析表为:

对指定串:(i+i)*i和(i+i)*分别分析后得到

虽说打印的时候没对齐,但结果是对的..

lwch 2010-07-21 20:24 发表评论

LR(0),SLR(1),LR(1)分析器源码

lwch — Sun, 18 Jul 2010 10:02:00 GMT

分析器

LR项目内有一宏定义可定义为LR0或SLR1
LR1分析器分析速度过慢有待优化..
求Follow集用了非递归算法,发现递归算法容易引起无限循环.
希望对正在学习编译原理的同学有所启发.

lwch 2010-07-18 18:02 发表评论

已实现LR(1)分析表的自动创建

lwch — Sat, 17 Jul 2010 05:59:00 GMT

对于给定文法:
E->E+T
E->E-T
E->T
T->T*F
T->T/F
T->F
F->(E)
F->i
生成LR(1)分析表得:

LR(1)分析表的确是无比的巨大啊...

lwch 2010-07-17 13:59 发表评论

已实现LR(1)DFA状态机的自动创建

lwch — Fri, 16 Jul 2010 08:03:00 GMT

对于给定文法:
E->E+T
E->E-T
E->T
T->T*F
T->T/F
T->F
F->(E)
F->i
生成DFA状态机得:

  1 该文法的拓展文法为：
  2 $->E
  3 E->E+T
  4 E->E-T
  5 E->T
  6 T->T*F
  7 T->T/F
  8 T->F
  9 F->(E)
10 F->i
11 该文法的项目如下：
12 (1) $->.E,#
13 (2) E->.E+T,#
14 (3) E->.E-T,#
15 (4) E->.T,#
16 (5) E->.E+T,+
17 (6) E->.E-T,+
18 (7) E->.T,+
19 (8) E->.E+T,-
20 (9) E->.E-T,-
21 (10) E->.T,-
22 (11) T->.T*F,#
23 (12) T->.T/F,#
24 (13) T->.F,#
25 (14) T->.T*F,+
26 (15) T->.T/F,+
27 (16) T->.F,+
28 (17) T->.T*F,-
29 (18) T->.T/F,-
30 (19) T->.F,-
31 (20) T->.T*F,*
32 (21) T->.T/F,*
33 (22) T->.F,*
34 (23) T->.T*F,/
35 (24) T->.T/F,/
36 (25) T->.F,/
37 (26) F->.(E),#
38 (27) F->.i,#
39 (28) F->.(E),+
40 (29) F->.i,+
41 (30) F->.(E),-
42 (31) F->.i,-
43 (32) F->.(E),*
44 (33) F->.i,*
45 (34) F->.(E),/
46 (35) F->.i,/
47 (36) $->E.,#
48 (37) E->E.+T,#
49 (38) E->E.-T,#
50 (39) E->E.+T,+
51 (40) E->E.-T,+
52 (41) E->E.+T,-
53 (42) E->E.-T,-
54 (43) E->T.,#
55 (44) E->T.,+
56 (45) E->T.,-
57 (46) T->T.*F,#
58 (47) T->T./F,#
59 (48) T->T.*F,+
60 (49) T->T./F,+
61 (50) T->T.*F,-
62 (51) T->T./F,-
63 (52) T->T.*F,*
64 (53) T->T./F,*
65 (54) T->T.*F,/
66 (55) T->T./F,/
67 (56) T->F.,#
68 (57) T->F.,+
69 (58) T->F.,-
70 (59) T->F.,*
71 (60) T->F.,/
72 (61) F->(.E),#
73 (62) E->.E+T,)
74 (63) E->.E-T,)
75 (64) E->.T,)
76 (65) T->.T*F,)
77 (66) T->.T/F,)
78 (67) T->.F,)
79 (68) F->.(E),)
80 (69) F->.i,)
81 (70) F->(.E),+
82 (71) F->(.E),-
83 (72) F->(.E),*
84 (73) F->(.E),/
85 (74) F->i.,#
86 (75) F->i.,+
87 (76) F->i.,-
88 (77) F->i.,*
89 (78) F->i.,/
90 (79) E->E+.T,#
91 (80) E->E+.T,+
92 (81) E->E+.T,-
93 (82) E->E-.T,#
94 (83) E->E-.T,+
95 (84) E->E-.T,-
96 (85) T->T*.F,#
97 (86) T->T*.F,+
98 (87) T->T*.F,-
99 (88) T->T*.F,*
100 (89) T->T*.F,/
101 (90) T->T/.F,#
102 (91) T->T/.F,+
103 (92) T->T/.F,-
104 (93) T->T/.F,*
105 (94) T->T/.F,/
106 (95) F->(E.),#
107 (96) E->E.+T,)
108 (97) E->E.-T,)
109 (98) F->(E.),+
110 (99) F->(E.),-
111 (100) F->(E.),*
112 (101) F->(E.),/
113 (102) E->T.,)
114 (103) T->T.*F,)
115 (104) T->T./F,)
116 (105) T->F.,)
117 (106) F->(.E),)
118 (107) F->i.,)
119 (108) E->E+T.,#
120 (109) E->E+T.,+
121 (110) E->E+T.,-
122 (111) E->E-T.,#
123 (112) E->E-T.,+
124 (113) E->E-T.,-
125 (114) T->T*F.,#
126 (115) T->T*F.,+
127 (116) T->T*F.,-
128 (117) T->T*F.,*
129 (118) T->T*F.,/
130 (119) T->T/F.,#
131 (120) T->T/F.,+
132 (121) T->T/F.,-
133 (122) T->T/F.,*
134 (123) T->T/F.,/
135 (124) F->(E).,#
136 (125) F->(E).,+
137 (126) F->(E).,-
138 (127) F->(E).,*
139 (128) F->(E).,/
140 (129) E->E+.T,)
141 (130) E->E-.T,)
142 (131) T->T*.F,)
143 (132) T->T/.F,)
144 (133) F->(E.),)
145 (134) E->E+T.,)
146 (135) E->E-T.,)
147 (136) T->T*F.,)
148 (137) T->T/F.,)
149 (138) F->(E).,)
150 项目规范族如下：
151 I0 { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35 }
152 I1 { 36, 37, 38, 39, 40, 41, 42 }
153 I2 { 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55 }
154 I3 { 56, 57, 58, 59, 60 }
155 I4 { 61, 62, 63, 64, 5, 6, 7, 8, 9, 10, 65, 66, 67, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 68, 69, 28, 29, 30, 31, 32, 33, 34, 35, 70, 71, 72, 73 }
156 I5 { 74, 75, 76, 77, 78 }
157 I6 { 79, 11, 12, 13, 20, 21, 22, 23, 24, 25, 26, 27, 32, 33, 34, 35, 80, 14, 15, 16, 28, 29, 81, 17, 18, 19, 30, 31 }
158 I7 { 82, 11, 12, 13, 20, 21, 22, 23, 24, 25, 26, 27, 32, 33, 34, 35, 83, 14, 15, 16, 28, 29, 84, 17, 18, 19, 30, 31 }
159 I8 { 85, 26, 27, 86, 28, 29, 87, 30, 31, 88, 32, 33, 89, 34, 35 }
160 I9 { 90, 26, 27, 91, 28, 29, 92, 30, 31, 93, 32, 33, 94, 34, 35 }
161 I10 { 95, 96, 97, 39, 40, 41, 42, 98, 99, 100, 101 }
162 I11 { 102, 44, 45, 103, 104, 48, 49, 50, 51, 52, 53, 54, 55 }
163 I12 { 105, 57, 58, 59, 60 }
164 I13 { 106, 62, 63, 64, 5, 6, 7, 8, 9, 10, 65, 66, 67, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 68, 69, 28, 29, 30, 31, 32, 33, 34, 35, 70, 71, 72, 73 }
165 I14 { 107, 75, 76, 77, 78 }
166 I15 { 108, 46, 47, 52, 53, 54, 55, 109, 48, 49, 110, 50, 51 }
167 I16 { 56, 59, 60, 57, 58 }
168 I17 { 61, 62, 63, 64, 5, 6, 7, 8, 9, 10, 65, 66, 67, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 68, 69, 28, 29, 30, 31, 32, 33, 34, 35, 72, 73, 70, 71 }
169 I18 { 74, 77, 78, 75, 76 }
170 I19 { 111, 46, 47, 52, 53, 54, 55, 112, 48, 49, 113, 50, 51 }
171 I20 { 114, 115, 116, 117, 118 }
172 I21 { 119, 120, 121, 122, 123 }
173 I22 { 124, 125, 126, 127, 128 }
174 I23 { 129, 65, 66, 67, 20, 21, 22, 23, 24, 25, 68, 69, 32, 33, 34, 35, 80, 14, 15, 16, 28, 29, 81, 17, 18, 19, 30, 31 }
175 I24 { 130, 65, 66, 67, 20, 21, 22, 23, 24, 25, 68, 69, 32, 33, 34, 35, 83, 14, 15, 16, 28, 29, 84, 17, 18, 19, 30, 31 }
176 I25 { 131, 68, 69, 86, 28, 29, 87, 30, 31, 88, 32, 33, 89, 34, 35 }
177 I26 { 132, 68, 69, 91, 28, 29, 92, 30, 31, 93, 32, 33, 94, 34, 35 }
178 I27 { 133, 96, 97, 39, 40, 41, 42, 98, 99, 100, 101 }
179 I28 { 85, 26, 27, 88, 32, 33, 89, 34, 35, 86, 28, 29, 87, 30, 31 }
180 I29 { 90, 26, 27, 93, 32, 33, 94, 34, 35, 91, 28, 29, 92, 30, 31 }
181 I30 { 95, 96, 97, 39, 40, 41, 42, 100, 101, 98, 99 }
182 I31 { 134, 103, 104, 52, 53, 54, 55, 109, 48, 49, 110, 50, 51 }
183 I32 { 105, 59, 60, 57, 58 }
184 I33 { 106, 62, 63, 64, 5, 6, 7, 8, 9, 10, 65, 66, 67, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 68, 69, 28, 29, 30, 31, 32, 33, 34, 35, 72, 73, 70, 71 }
185 I34 { 107, 77, 78, 75, 76 }
186 I35 { 135, 103, 104, 52, 53, 54, 55, 112, 48, 49, 113, 50, 51 }
187 I36 { 136, 115, 116, 117, 118 }
188 I37 { 137, 120, 121, 122, 123 }
189 I38 { 138, 125, 126, 127, 128 }
190 I39 { 114, 117, 118, 115, 116 }
191 I40 { 119, 122, 123, 120, 121 }
192 I41 { 124, 127, 128, 125, 126 }
193 I42 { 131, 68, 69, 88, 32, 33, 89, 34, 35, 86, 28, 29, 87, 30, 31 }
194 I43 { 132, 68, 69, 93, 32, 33, 94, 34, 35, 91, 28, 29, 92, 30, 31 }
195 I44 { 133, 96, 97, 39, 40, 41, 42, 100, 101, 98, 99 }
196 I45 { 136, 117, 118, 115, 116 }
197 I46 { 137, 122, 123, 120, 121 }
198 I47 { 138, 127, 128, 125, 126 }
199 状态转移表如下：
200 I0 -> I1 [ E ]
201 I0 -> I2 [ T ]
202 I0 -> I3 [ F ]
203 I0 -> I4 [ ( ]
204 I0 -> I5 [ i ]
205 I1 -> I6 [ + ]
206 I1 -> I7 [ - ]
207 I2 -> I8 [ * ]
208 I2 -> I9 [ / ]
209 I4 -> I10 [ E ]
210 I4 -> I11 [ T ]
211 I4 -> I12 [ F ]
212 I4 -> I13 [ ( ]
213 I4 -> I14 [ i ]
214 I6 -> I15 [ T ]
215 I6 -> I16 [ F ]
216 I6 -> I17 [ ( ]
217 I6 -> I18 [ i ]
218 I7 -> I19 [ T ]
219 I7 -> I16 [ F ]
220 I7 -> I17 [ ( ]
221 I7 -> I18 [ i ]
222 I8 -> I20 [ F ]
223 I8 -> I4 [ ( ]
224 I8 -> I5 [ i ]
225 I9 -> I21 [ F ]
226 I9 -> I4 [ ( ]
227 I9 -> I5 [ i ]
228 I10 -> I22 [ ) ]
229 I10 -> I23 [ + ]
230 I10 -> I24 [ - ]
231 I11 -> I25 [ * ]
232 I11 -> I26 [ / ]
233 I13 -> I27 [ E ]
234 I13 -> I11 [ T ]
235 I13 -> I12 [ F ]
236 I13 -> I13 [ ( ]
237 I13 -> I14 [ i ]
238 I15 -> I28 [ * ]
239 I15 -> I29 [ / ]
240 I17 -> I30 [ E ]
241 I17 -> I11 [ T ]
242 I17 -> I12 [ F ]
243 I17 -> I13 [ ( ]
244 I17 -> I14 [ i ]
245 I19 -> I28 [ * ]
246 I19 -> I29 [ / ]
247 I23 -> I31 [ T ]
248 I23 -> I32 [ F ]
249 I23 -> I33 [ ( ]
250 I23 -> I34 [ i ]
251 I24 -> I35 [ T ]
252 I24 -> I32 [ F ]
253 I24 -> I33 [ ( ]
254 I24 -> I34 [ i ]
255 I25 -> I36 [ F ]
256 I25 -> I13 [ ( ]
257 I25 -> I14 [ i ]
258 I26 -> I37 [ F ]
259 I26 -> I13 [ ( ]
260 I26 -> I14 [ i ]
261 I27 -> I38 [ ) ]
262 I27 -> I23 [ + ]
263 I27 -> I24 [ - ]
264 I28 -> I39 [ F ]
265 I28 -> I17 [ ( ]
266 I28 -> I18 [ i ]
267 I29 -> I40 [ F ]
268 I29 -> I17 [ ( ]
269 I29 -> I18 [ i ]
270 I30 -> I41 [ ) ]
271 I30 -> I23 [ + ]
272 I30 -> I24 [ - ]
273 I31 -> I42 [ * ]
274 I31 -> I43 [ / ]
275 I33 -> I44 [ E ]
276 I33 -> I11 [ T ]
277 I33 -> I12 [ F ]
278 I33 -> I13 [ ( ]
279 I33 -> I14 [ i ]
280 I35 -> I42 [ * ]
281 I35 -> I43 [ / ]
282 I42 -> I45 [ F ]
283 I42 -> I33 [ ( ]
284 I42 -> I34 [ i ]
285 I43 -> I46 [ F ]
286 I43 -> I33 [ ( ]
287 I43 -> I34 [ i ]
288 I44 -> I47 [ ) ]
289 I44 -> I23 [ + ]
290 I44 -> I24 [ - ]

由此可见LR(1)分析表会变得无比的巨大.

lwch 2010-07-16 16:03 发表评论

已实现SLR(1)分析表的自动创建

lwch — Mon, 12 Jul 2010 16:00:00 GMT

对于给定二义性文法:
E->E+T
E->E-T
E->T
T->T*F
T->T/F
T->F
F->(E)
F->i
求得SLR(1)分析表为:

lwch 2010-07-13 00:00 发表评论

关于字符串操作的注意事项

lwch — Sun, 11 Jul 2010 10:38:00 GMT

首先我们探讨几个问题:
CString str = L"";
str += 'a' + L"a";
或str += L"a" + 'a';
分别会得到什么?
答案是一堆一样的乱码.
这是为什么呢?
由于运算符的优先级的关系先计算'a' + L"a"或L"a" + 'a'当字符串与单个字符相加时编译器认为是将指针向后移动'a'(0x61)个字节,最后进入CString的+=运算符重载函数,由于传入的是一个字符串指针所以函数会将从L"a"+0x61的位置开始到\0结尾的所有字符连接到原字符后.应此也就出现了乱码的情况.
解决方法:
CString str = L"";
str += CString('a') + L"a";
或str += CString(L"a") + 'a';
在做加法运算时都会进入CString的+运算符的重载函数以得到正确的结果.

lwch 2010-07-11 18:38 发表评论

已实现LR(0)分析表的自动构造

lwch — Sun, 11 Jul 2010 09:05:00 GMT

对于给定文法:
S->aAcBe
A->b
A->Ab
B->d
生成分析表得:

1 LR(0)分析表为：
2     a    c    e    b    d    #    S    A    B
3 0    S2    ε    ε    ε    ε    ε    1    ε    ε
4 1    ε    ε    ε    ε    ε    acc    ε    ε    ε
5 2    ε    ε    ε    S4    ε    ε    ε    3    ε
6 3    ε    S5    ε    S6    ε    ε    ε    ε    ε
7 4    R2    R2    R2    R2    R2    R2    ε    ε    ε
8 5    ε    ε    ε    ε    S8    ε    ε    ε    7
9 6    R3    R3    R3    R3    R3    R3    ε    ε    ε
10 7    ε    ε    S9    ε    ε    ε    ε    ε    ε
11 8    R4    R4    R4    R4    R4    R4    ε    ε    ε
12 9    R1    R1    R1    R1    R1    R1    ε    ε    ε

lwch 2010-07-11 17:05 发表评论

已实现从文法树到ε-Parser的转换

lwch — Fri, 09 Jul 2010 09:45:00 GMT

对于给定文法:

exp->exp1

exp1->exp2 | exp5

exp5->exp1 (“<” | “>” | “==”) exp2

exp2->exp3 | exp6

exp6->exp2 (“+” | “-“) exp3

exp3->exp4 | exp7

exp7->exp3(“*” | “/”) exp4

exp4->”(“ exp “)”

生成ε-Parser得:

1 ε- Parser:
2 Start:28
3 X:        Type        From        To
4 (:        0        0        1(finial)
5 ):        0        2        3(finial)
6 ε:        2        1(finial)        0
7 ε:        2        1(finial)        2
8 *:        0        4        5(finial)
9 /:        0        6        7(finial)
10 ε:        2        8        4
11 ε:        2        5(finial)        9(finial)
12 ε:        2        8        6
13 ε:        2        7(finial)        9(finial)
14 ε:        2        3(finial)        8
15 ε:        2        9(finial)        8
16 ε:        2        10        0
17 ε:        2        3(finial)        11(finial)
18 ε:        2        10        0
19 ε:        2        9(finial)        11(finial)
20 +:        0        12        13(finial)
21 -:        0        14        15(finial)
22 ε:        2        16        12
23 ε:        2        13(finial)        17(finial)
24 ε:        2        16        14
25 ε:        2        15(finial)        17(finial)
26 ε:        2        11(finial)        16
27 ε:        2        17(finial)        16
28 ε:        2        18        10
29 ε:        2        11(finial)        19(finial)
30 ε:        2        18        10
31 ε:        2        17(finial)        19(finial)
32 <:        0        20        21(finial)
33 >:        0        22        23(finial)
34 ==:        1        24        25(finial)
35 ε:        2        26        20
36 ε:        2        21(finial)        27(finial)
37 ε:        2        26        22
38 ε:        2        23(finial)        27(finial)
39 ε:        2        26        24
40 ε:        2        25(finial)        27(finial)
41 ε:        2        19(finial)        26
42 ε:        2        27(finial)        26
43 ε:        2        28        18
44 ε:        2        19(finial)        29(finial)
45 ε:        2        28        18
46 ε:        2        27(finial)        29(finial)

缺点:必须手动生成文法树
下一步是去除ε边

lwch 2010-07-09 17:45 发表评论

用正则表达式构造词法分析器

lwch — Sat, 03 Jul 2010 10:14:00 GMT

《用正则表达式构造词法分析器》
这篇文章阐述了如何用正则表达式构造语法树并生成ε-NFA，去除ε边转换到NFA，最后转换到DFA的所有过程。学习编译原理的朋友们如果遇到什么问题不妨看下这篇文章。
源码下载

lwch 2010-07-03 18:14 发表评论

已实现简单正则表达式->ε-NFA->NFA->DFA的转换

lwch — Fri, 02 Jul 2010 16:21:00 GMT

稍后制作相关文档..

  1Regex Expression:(ab|a[a-z0-9]+|cd)*
  2CharClassList:
  3*        0
  4|        1
  5a        2
  6b        3
  7+        4
  8a - z        5
  90 - 9        6
10c        7
11d        8
12
13ε-NFA:
14Start:26 End:26
15X:From    To
162:0        1
173:2        3
18ε:1        2
192:4        5
205:6        7
216:8        9
22ε:10        6
23ε:10        8
24ε:7        11
25ε:9        11
265:12        13
276:14        15
28ε:16        12
29ε:16        14
30ε:13        17
31ε:15        17
32ε:17        10
33ε:11        17
34ε:5        16
35ε:18        0
36ε:18        4
37ε:3        19
38ε:17        19
397:20        21
408:22        23
41ε:21        22
42ε:24        18
43ε:24        20
44ε:19        25
45ε:23        25
46ε:26        24
47ε:25        26
48
49NFA:
50Start:26
51X:From    To
527:26(finial)        21
532:26(finial)        1
542:26(finial)        5
553:1        3(finial)
567:3(finial)        21
572:3(finial)        1
582:3(finial)        5
595:5        13(finial)
606:5        15(finial)
615:7(finial)        7(finial)
626:7(finial)        9(finial)
637:7(finial)        21
642:7(finial)        1
652:7(finial)        5
665:9(finial)        7(finial)
676:9(finial)        9(finial)
687:9(finial)        21
692:9(finial)        1
702:9(finial)        5
715:13(finial)        7(finial)
726:13(finial)        9(finial)
737:13(finial)        21
742:13(finial)        1
752:13(finial)        5
765:15(finial)        7(finial)
776:15(finial)        9(finial)
787:15(finial)        21
792:15(finial)        1
802:15(finial)        5
818:21        23(finial)
827:23(finial)        21
832:23(finial)        1
842:23(finial)        5
85
86DFA:
87Start:26
88X:Froms        Tos
897:26 (finial)        21
902:26 (finial)        1 5
918:21         23 (finial)
923:1 5         3 (finial)
935:1 5         13 (finial)
946:1 5         15 (finial)
957:23 (finial)        21
962:23 (finial)        1 5
977:3 (finial)        21
982:3 (finial)        1 5
995:13 (finial)        7 (finial)
1006:13 (finial)        9 (finial)
1017:13 (finial)        21
1022:13 (finial)        1 5
1035:15 (finial)        7 (finial)
1046:15 (finial)        9 (finial)
1057:15 (finial)        21
1062:15 (finial)        1 5
1075:7 (finial)        7 (finial)
1086:7 (finial)        9 (finial)
1097:7 (finial)        21
1102:7 (finial)        1 5
1115:9 (finial)        7 (finial)
1126:9 (finial)        9 (finial)
1137:9 (finial)        21
1142:9 (finial)        1 5

lwch 2010-07-03 00:21 发表评论

NScript词法分析器,语法分析器,代码生成器已制作完成

lwch — Sat, 26 Jun 2010 02:57:00 GMT

由于未进行类型检查直接生成的虚拟机代码所以可以在代码中直接使用变量.
Do语句:

For语句:

Function:

If语句:

Local语句:

Switch语句:

While语句:

阶乘:

lwch 2010-06-26 10:57 发表评论

NScript部分文法

lwch — Sat, 26 Jun 2010 02:37:00 GMT

sym->[a-z|A-Z|_][a-z|A-Z|0-9|_]*

int->[0-9]+

real->[0-9]+.[0-9]+

string->

datatype->”int” | “real” | “bool” | “string”

prgama->function | functionheader “;”

functionheader->”function” sym ”(“ parameters ”)” [“as” datatype]

parameters->[[sym as datatype],parameters]

function->functionheader “{“ block “}”

block->statementlist

local-stmt->”local” varlist

varlist->symlist “as” datatype [“,” varlist]

if-stmt->”if” exp statementlist [“else” statementlist]

while-stmt->”while” exp statementlist

do-stmt->”do” statementlist “while” exp “;”

for-stmt->”for” “(“ exp “;” exp “;” exp “)” statementlist

switch-stmt->”switch” exp “{“ case-stmt “}”

case-stmt->(”case” sym | “default”) “:” statementlist case-stmt

assign-stmt->exp “=” exp

call-stmt->sym “(“ parameters “)” “;”

return-stmt->”return” exp

symlist->sym [“,” symlist]

statement->“{“ statementlist “}”

statement->”;”

statementlist->statement [statementlist]

exp->exp1

exp1->exp2

exp1->exp1 (“<” | “<=” | “=” | “>=” | “>” | “!=”) exp2

exp2->exp3

exp2->exp2 (“+” | “-“) exp3

exp3->exp4

exp3->exp3(“*” | “/”) exp4

exp4->”(“ exp “)”

lwch 2010-06-26 10:37 发表评论