今天使用智能指針LytPtr初步完成了表達式樹，未調試完全，頭文件代碼如下：

 1class Interpret
 2{
 3public:
 4  Error ErrorInfomation;
 5
 6  bool IsError();
 7  LytPtr<Program> Run(const LytWString Content);
 8
 9private:
10  LytPtr<Program> GetProgram(Node<Token*>*& Current);
11  LytPtr<Function> GetFunction(Node<Token*>*& Current);
12  LytPtr<Var> GetVar(Node<Token*>*& Current);
13  LytPtr<Block> GetBlock(Node<Token*>*& Current);
14  LytPtr<FunHead> GetFunHead(Node<Token*>*& Current);
15  LytPtr<FunHead> GetFunctionHead(Node<Token*>*& Current);
16  LytPtr<FunHead> GetProcedureHead(Node<Token*>*& Current);
17  LytPtr<Statement> GetStatement(Node<Token*>*& Current);
18  LytPtr<Statement> GetAssignStatementOrSimpleStatement(Node<Token*>*& Current);
19  LytPtr<Statement> GetIfStatement(Node<Token*>*& Current);
20  LytPtr<Statement> GetWhileDoStatement(Node<Token*>*& Current);
21  LytPtr<Statement> GetDoWhileStatement(Node<Token*>*& Current);
22  LytPtr<Statement> GetControlStatement(Node<Token*>*& Current);
23  LytPtr<Statement> GetReturnStatement(Node<Token*>*& Current);
24  LytPtr<Statement> GetCompoundStatement(Node<Token*>*& Current);
25  LytPtr<Expression> GetExpression(Node<Token*>*& Current);
26  LytPtr<Expression> GetRelationExpression(Node<Token*>*& Current);
27  LytPtr<Expression> GetXorExpression(Node<Token*>*& Current);
28  LytPtr<Expression> GetOrExpression(Node<Token*>*& Current);
29  LytPtr<Expression> GetAddSubExpression(Node<Token*>*& Current);
30  LytPtr<Expression> GetAndExpression(Node<Token*>*& Current);
31  LytPtr<Expression> GetMulDivExpression(Node<Token*>*& Current);
32  LytPtr<Expression> GetPositiveNegativeExpression(Node<Token*>*& Current);
33  LytPtr<Expression> GetNotExpression(Node<Token*>*& Current);
34  LytPtr<Expression> GetSimpleExpression(Node<Token*>*& Current);
35  LytPtr<Expression> GetCallFunctionExpression(Node<Token*>*& Current);
36};

其中，關于優先級的設計有點迷惑，參考了網上關于Pascal操作符優先級后，文法如下：

Expression = RelationExpression;
RelationExpression = RelationExpression ("<" | "<=" | "=" | "!=" | ">" | ">=") XorExpression | XorExpression
XorExpression = XorExpression "xor" OrExpression | OrExpression
OrExpression = OrExpression "or" AddExpression | AddSubExpression
AddSubExpression = AddSubExpression ("+" | "-") AndExpression | AndExpression
AndExpression = AndExpression "and" MulDivExpression | MulDivModExpression
MulDivModExpression = MulDivModExpression ("*" | "div" | "mod") UnaryExpression | UnaryExpression
PositiveNegativeExpression = ("+" | "-") NotExpression | NotExpression
NotExpression = "not" SimpleExpression | SimpleExpression;
SimpleExpression = Number | bool | CallFunctionExpression

代碼舉例：

 1LytPtr<Expression> GetAddSubExpression(Node<Token*>*& Current)
 2{
 3    if (!Current) return 0;
 4    else
 5    {
 6        LytPtr<Expression> Result=GetAndExpression(Current);
 7        if (IsError()) return 0;
 8        else
 9        {
10            while (Current && (Current->Data->Content==L"+" || Current->Data->Content==L"-"))
11            {
12                LytPtr<Expression> Left=Result;
13                Result=new BinaryExpression;
14                BinaryExpression* Temp=(BinaryExpression*)Result.Buffer();
15                Temp->Left=Left;
16                Temp->Operator=*(Current->Data);
17                Current=Current->Next;
18                if (!Current)
19                {
20                    ErrorInfomation.SetMessage(L"加減表達式缺少右操作數 =>"+ErrorInfomation.GetMessage());
21                    return 0;
22                }
23                LytPtr<Expression> Right=GetAndExpression(Current);
24                if (IsError())
25                {
26                    ErrorInfomation.SetMessage(L"加減表達式右操作數出錯 =>"+ErrorInfomation.GetMessage());
27                    return 0;
28                }
29                else Temp->Right=Right;
30            }
31            return Result;
32        }
33    }
34}
35
36LytPtr<Expression> GetMulDivExpression(Node<Token*>*& Current)
37{
38    if (!Current) return 0;
39    else
40    {
41        LytPtr<Expression> Result=GetPositiveNegativeExpression(Current);
42        if (IsError()) return 0;
43        else
44        {
45            while (Current && (Current->Data->Content==L"*" || Current->Data->Content==L"div"))
46            {
47                LytPtr<Expression> Left=Result;
48                Result=new BinaryExpression;
49                BinaryExpression* Temp=(BinaryExpression*)Result.Buffer();
50                Temp->Left=Left;
51                Temp->Operator=*(Current->Data);
52                Current=Current->Next;
53                if (!Current)
54                {
55                    ErrorInfomation.SetMessage(L"*/div表達式缺少右操作數 =>"+ErrorInfomation.GetMessage());
56                    return 0;
57                }
58                LytPtr<Expression> Right=GetPositiveNegativeExpression(Current);
59                if (IsError())
60                {
61                    ErrorInfomation.SetMessage(L"*/div表達式右操作數出錯 =>"+ErrorInfomation.GetMessage());
62                    return 0;
63                }
64                else Temp->Right=Right;
65            }
66            return Result;
67        }
68    }
69}

不難發現，含有二元操作符的表達式文法接近（一元也一樣），函數實現方法也類似，為了讓代碼好看點，我動了幾個念頭，但最終沒實現：

1.函數模板

2.函數指針：利用typedef，后來發現定義過程中有遞歸，遂寫不出來，暫時放棄

3.宏：記得括號來括號去那里要加得很清楚，腦袋暈乎，暫時放棄

晚上睡覺能想到啥好辦法明天再解決。

在構造表達式樹的時候還出現了幾個問題：

1.先前由于我沒有充分測試，LytPtr有bug，自食其果了

結論：寫出啥數據結構在使用前一定要充分測試

2.猶豫到底該用返回什么類型的指針，暫時還不明白返回LytPtr<Expression>與返回LytPtr<Base>的區別，其中Expression是繼承Base的

3.LytPtr不支持類型轉換，于是在需要類型轉換的時候愣了幾下，忘記可以轉成指針來用了

結論：該用指針的時候還是用指針

希望明天完成測試表達式樹與類型檢查。