程序最美(寻路)

你还在坚持练习你的技术吗?运动员天天训练,音乐家也会演练更难的曲章。你呢?

语法分析器初步学习——LISP语法分析

语法分析器初步学习——LISP语法分析

         本文参考自vczh的《如何手写语法分析器》。

         LISP的表达式是按照前缀的形式写的,比如(1+2)*(3+4)在LISP中会写成(*(+ 1 2)(+ 3 4)),1 + 2会写成(+ 1 2)。

         LISP语言的语法如下形式:

1.Operator = “+” | “-” | “*” | “/”

         2.Expression = <数字> | ”(”Expression”)” | “(”Operator Expression Expression”)”

         我们根据以上两条语法规则来写代码:

// LISP语法分析器
#include <iostream>
#include <string>
using namespace std;

// 检测是否是空白符
bool IsBlank(char ch)
{
    return ch == ' ' || ch == '\t';
}

// 检测Text是否是Stream的前缀
// 如果是前缀,则返回true,并将pos前移Text.size()个字符
// 如果不是前缀,则返回false
// 此函数一开始会过滤掉Stream开头的空格
bool IsPrefix(const string& Stream, int& pos, const string& Text)
{
    int read = pos;

    // 过滤空白符
    while (IsBlank(Stream[read]))
    {
        ++read;
    }
    // 不能写为:
    // while (IsBlank(Stream[read++]));
    // 因为这样写会导致read至少加1

    if (Stream.substr(read, Text.size()) == Text) // 如果是前缀
    {
        pos = read + Text.size();
        return true;
    }
    else
    {
        return false;
    }
}

// 检测Stream开头是否是操作符+、-、*、/
// 是的话,函数返回实际的操作符,并将pos便宜到操作符之后
// 否则返回0
// 判断语法1:Operator = “+” | “-” | “*” | “/”
char IsOperator(const string& Stream, int& pos)
{
    if (IsPrefix(Stream, pos, "+")
     || IsPrefix(Stream, pos, "-")
     || IsPrefix(Stream, pos, "*")
     || IsPrefix(Stream, pos, "/")) // 如果开头是操作符
    {
        return Stream[pos - 1]; // 如果是的话,pos已经向前偏移了
    }
    else
    {
        return 0;
    }
}

// 表达式结构体
struct Expression
{
    int Result;   // 返回表达式结果
    string Error; // 返回错误信息,没错误则为空
    int Start;    // 错误发生的位置

    Expression() : Result(0), Start(0) {}
};

// 检测Stream开头是否是数字,如果是,则将pos便宜到数字之后
// 函数返回Expression
// 判断语法2中的第一部分:Expression = <数字>
Expression GetNumber(const string& Stream, int& pos)
{
    Expression Result;

    bool GotNumber = false;

    int read = pos;

    // 过滤空白符
    while (IsBlank(Stream[read]))
    {
        ++read;
    }

    while (true)
    {
        // 依次读入一个字符
        char ch = Stream[read];
        if (ch >= '0' && ch <= '9')
        {
            Result.Result = Result.Result * 10 + ch - '0';
            GotNumber = true;
            ++read;
        }
        else
        {
            break;
        }
    }

    if (GotNumber)
    {
        pos = read;
    }
    else
    {
        Result.Error = "这里需要数字";
        Result.Start = read;
    }

    return Result;
}

// 检测Stream开头是否是表达式
// 如果是,则将pos前移到表达式后
// 实现语法2:Expression = <数字> | “(”Expression“)” | “(”Operator Expression Expression“)”
Expression GetExpression(const string& Stream, int& pos)
{
    int read = pos;

    // 检测开头是否是数字
    // 语法2第一部分:Expression = <数字>
    Expression Result = GetNumber(Stream, read);

    if (!Result.Error.empty()) // 如果开头不是数字
    {
        if (IsPrefix(Stream, read, "(")) // 检测是否"("开头
        {
            // 将Result的Error清空
            Result.Error.clear();

            char Operator = 0;
            if ((Operator = IsOperator(Stream, read)) != 0)
            // 如果是操作符,语法2第三部分:Expression = “(”Operator Expression Expression“)”
            {
                // 获取左参数
                // 递归调用
                Expression left = GetExpression(Stream, read);
                if (!left.Error.empty())
                {
                    return left;
                }
                // 保持当前read
                int rightRead = read;
                // 获取右参数
                // 递归调用
                Expression right = GetExpression(Stream, read);
                if (!right.Error.empty())
                {
                    return right;
                }

                // 根据操作符Operator进行计算
                switch (Operator)
                {
                case '+':
                    Result.Result = left.Result + right.Result;
                    break;

                case '-':
                    Result.Result = left.Result - right.Result;
                    break;

                case '*':
                    Result.Result = left.Result * right.Result;
                    break;

                case '/':
                    if (right.Result == 0) // 除数为0
                    {
                        Result.Error = "除数为0";
                        Result.Start = rightRead;
                    }
                    else
                    {
                        Result.Result = left.Result / right.Result;
                    }
                    break;

                default: // 这种情况不会发生,因为前提是Operator,所以只有+、-、*、/四种情况
                    Result.Error = "未知的操作符";
                    Result.Start = read;
                    return Result;
                }
            }
            else
            // 如果不是操作符
            // 语法2的第二部分:Expression = “(”Expression“)”
            {
                // 获取表达式
                Result = GetExpression(Stream, read);
                // 如果获取失败,则直接返回
                if (!Result.Error.empty())
                {
                    return Result;
                }
            }

            // 检测是否有配套的")"
            if (!IsPrefix(Stream, read, ")"))
            {
                Result.Error = "此处缺少右括号";
                Result.Start = read;
            }
        }
    }

    // 如果没有出错,则更新pos
    if (Result.Error.empty())
    {
        pos = read;
    }

    // 检测是否有配套")"时,如果不存在,可以直接将Result返回
    // 这样在后面就不用检测是否出错了,因为前面凡是出错的情况
    // 都返回了,这样就不用检测了,而直接更新pos: pos = read

    return Result;
}


// 测试
int main()
{
    while (true)
    {
        string Stream;
        cout << "输入一个LISP表达式" << endl;
        getline(cin, Stream);

        int pos = 0;

        if (IsPrefix(Stream, pos, "exit"))
        {
            break;
        }

        pos = 0;

        Expression Result = GetExpression(Stream, pos);
        if (!Result.Error.empty())
        {
            cout << "表达式错误" << endl;
            cout << "位置:" << Result.Start << endl;
            cout << "错误信息:" << Result.Error << endl;
        }
        else
        {
            cout << "结果:" << Result.Result << endl;
        }
    }

    return 0;
}

         下面对程序代码解释如下:

         数据结构

         程序中用string型的字符串Stream来存储用户输入的表达式,int型的pos 作为当前扫描的位置。

         Expression结构体用来标识语法二中的Expression,Expression结构体可以标识<数字> | ”(”Expression”)” | “(”Operator Expression Expression”)”三种形式的任意一种。Result元素用来记录正确表达式时的计算结果,Error用来当语法分析表达式时遇到的错误时,将错误信息记录下来。Start用来记录错误的位置,准确来讲是用来记录最后正确的下一个位置,因为错误字符串前的空白符会被忽略。

         函数

         IsBlank:用来检测char字符是否为空白符。

         IsPrefix:用来检测Text字符串是否是Stream从pos起头的前缀。

         IsOperator:用来检测Stream从pos起头,是否是以操作符+、-、*、/开头的。

         GetNumber:用来检测Stream从pos起头,是否是以数字开头的。

         GetExpression:用来检测Stream从pos开头,是否以表达式开头。

         语法分析器的关键在于写出正确的语法,然后根据语法导出代码。语法定义中存在递归定义,代码中相应地也会出现递归调用。代码应该一一对应的对应到语法定义。

         设计的巧妙之处

         pos和read:pos用来标识扫描的位置,pos只用来记录正确分析的位置。在IsPrefix、GetNumber、GetExpression等函数中,都会在定义一个read,初始化为pos,用来作为实际的扫描游标,只有在正确分析后,read才会用来更新pos,否则read会返回给Result的Start,用来记录错误发生的位置,并且直接返回Result。用read来代替pos的内部操作,可以防止当分析失败时,还要讲pos还原的问题。

         Expression结构体:Expression结构包含三个元素,Start和Error字段可以很地记录错误发生的位置以及错误信息。这样可以很好的处理发生错误的情况。

 

         以上是最为简单的递归下降语法分析,更多的语法分析方面的知识有待进一步学习。

posted on 2013-09-15 21:58  unixfy  阅读(2374)  评论(0编辑  收藏  举报

导航