编译原理

感谢vczh轮子叔的坑了的教程，我的编译原理第一次入了个门，词法分析写完了，今后可以看看书继续往下学了。

http://www.cppblog.com/vczh/archive/2014/03/02/206014.html

词法分析，就是对于一段代码，把他们分割成一个个的token，同时记录他们的行列号，丢掉不必要的信息，这个词法分析器很简单，简单的状态机就能胜任，用正则就没有自己造轮子的快感了，所以要自己手撸状态机拆token出来。

模仿vczh的语言，我的语言包括了以下要素

　　标识符：大小写字母和下划线构成的连续串[a-zA-Z_]

　　数字：自然书写的整数和浮点数，整数部分为0的浮点数必须要用0.开头

　　运算符：单个符号

　　注释：#开头，#或 结尾的任意内容，也就是说注释最多是一整行

　　字符串：双引号"开头结尾的任意内容，支持\， 两种转义字符。

这样简单的语言，用正则表达式处理也很简单，但是为了贯彻自己造轮子的原则，我们手写一波状态机

首先把状态机的图画出来，就像这样（因为没有钱买visio，所以只能用一个叫lucidchart的在线应用画图了）

虚线表示这个状态可以直接跳到End状态，而所谓End状态就是Start状态，所以到了有虚线的状态，可以看情况直接跳到Start，并且有些状态也可以直接优化掉，比如InStringEnd, InOperator等，遇到这样的状态，直接输出一个token，然后把state设为Start就好了。

这样的状态机是不是很简单，更加复杂的一些状态，也可以手动构造正则表达式，然后用vczh的另一篇教程手写出状态机来。

忘了说Token的结构了，这个很简单

struct Token
{
    int line;
    int column;
    TokenType type;
    std::wstring value;
    Token(): Token(0, 0, TokenType::Unknown, L"", 0)
    {
    }
    Token(int _line, int _column, TokenType _type, const wchar_t* str, int len)
        : line(_line)
        , column(_column)
        , type(_type)
        , value(str, len)
    {
    }
    void Reset()
    {
        line = 0;
        column = 0;
        type = TokenType::Unknown;
        value.clear();
    }
    void Push(const wchar_t ch)
    {
        value.push_back(ch);
    }
};

那个Reset和Push纯粹是因为我偷懒，把这个第一个版本的代码写得很烂，只能用这种不科学的封装来减少一下代码的重复了。

有了状态机和具体的状态：

enum class TokenType
{
    Unknown,
    Number,
    Comment,
    Operator,
    Identifier,
    String
};

enum class ParseState
{
    Begin,
    InComment,
    //InCommentEnd,
    InInteger,
    InFloat,
    InOperator,
    InIdentifier,
    InString,
    InStringEscaping,
    //InStringEnd
};

可以构造状态机了，模板是这样的：

while (*reading)
{
    switch (state)
    {
    case 某个状态:
    {
        switch (*reading)
        {
        case 某个或某几个字符:
            #根据状态机里当前状态能接受和不能接受的字符，修改新的状态，读入字符，reading++，或者直接抛异常
        break;
        }
    }
}

第一个版本的代码写得很烂，纯粹是能用的程序，放在这里纯粹是显摆一下，之后我会考虑重构什么的，然后再来更新这篇文章，而且没有写单元测试，正确性纯粹是肉眼检查，报错信息也很不友善，这一点下一个版本的代码再改。

更新，稍微优化了一下，重复代码少了不少，我很喜欢，还能接着改

下面贴代码：

TokenStream.h

#pragma once
#ifndef TOKEN_STREAM
#define TOKEN_STREAM

#include <string>
#include <vector>
enum class TokenType
{
    Unknown,
    Number,
    Comment,
    Operator,
    Identifier,
    String
};

enum class ParseState
{
    Begin,
    InComment,
    //InCommentEnd,
    InInteger,
    InFloat,
    InOperator,
    InIdentifier,
    InString,
    InStringEscaping,
    //InStringEnd
};
struct Token
{
    int line;
    int column;
    TokenType type;
    std::wstring value;
    Token(int _line, int _column, TokenType _type, const wchar_t* begin, const wchar_t* end)
        : line(_line)
        , column(_column)
        , type(_type)
        , value(begin, end)
    {
        if (type == TokenType::String)
        {
            for (size_t i = 0; i < value.length(); i++)
            {
                if (value[i] == '\')
                {
                    if (i + 1 < value.length())
                    {
                        switch (value[i + 1])
                        {
                        case'\':
                        {
                            value.replace(i, 2, 1, '\');
                            break;
                        }
                        case'n':
                        {
                            value.replace(i, 2, 1, '
');
                            break;
                        }
                        case'"':
                        {
                            value.replace(i, 2, 1, '"');
                            break;
                        }
                        default:
                        {
                            throw std::exception("error in escaping");
                            break;
                        }
                        }
                    }
                    else
                    {
                        throw std::exception("error in escaping");
                    }
                }
            }
        }
    }
};

class TokenStream
{
private:
    struct ParsingState
    {
        ParseState State;
        int Line;
        int Column;
        const wchar_t* TokenStart;
        const wchar_t* TokenEnd;
    };
    std::vector<Token> tokenList;
    
    void PushToken(ParsingState& state, TokenType type)
    {
        tokenList.push_back(Token(state.Line, state.Column, type, state.TokenStart, state.TokenEnd));
    }
public:
    std::vector<Token> Parse(std::wstring& source)
    {
        ParsingState state{ParseState::Begin, 0, 0, source.c_str(), source.c_str()};
        int lineNumber = 1;
        int columnNumber = 1;

        while (*state.TokenEnd)
        {
            switch (state.State)
            {
            case ParseState::Begin:
            {
                state.TokenStart = state.TokenEnd;
                state.Column = columnNumber;
                state.Line = lineNumber;
                switch (*state.TokenEnd)
                {
                case'+':case'-':case'*':case'/':case'(':case')':case'<':case'>':case'=':case';':
                case'^':case'&':case'.':
                {
                    state.TokenEnd++;
                    PushToken(state, TokenType::Operator);
                    state.TokenEnd--;
                    break;
                }
                case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':
                {
                    state.State = ParseState::InInteger;
                    break;
                }
                case'a':case'b':case'c':case'd':case'e':case'f':case'g':case'h':case'i':case'j':case'k':case'l':case'm':case'n':case'o':case'p':case'q':case'r':case's':
                case't':case'u':case'v':case'w':case'x':case'y':case'z':case'A':case'B':case'C':case'D':case'E':case'F':case'G':case'H':case'I':case'J':case'K':case'L':
                case'M':case'N':case'O':case'P':case'Q':case'R':case'S':case'T':case'U':case'V':case'W':case'X':case'Y':case'Z':case'_':
                {
                    state.State = ParseState::InIdentifier;
                    break;
                }
                case'#':
                {
                    state.TokenStart++;
                    state.State = ParseState::InComment;
                    break;
                }
                case'"':
                {
                    state.TokenStart++;
                    state.State = ParseState::InString;
                    break;
                }
                case'
':
                {
                    lineNumber++;
                    columnNumber = 0;
                    break;
                }
                case' ':
                {
                    break;
                }
                default:
                {
                    throw std::exception("parse error");
                    break;
                }
                }
                break;
            } //case ParseState::Begin
            case ParseState::InInteger:
            {
                switch (*state.TokenEnd)
                {
                case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':
                {
                    break;
                }
                case'.':
                {
                    state.State = ParseState::InFloat;
                    break;
                }
                default:
                {
                    state.State = ParseState::Begin;
                    PushToken(state, TokenType::Number);
                    state.TokenEnd--;
                    columnNumber--;
                    break;
                }
                }
                break;
            } //case ParseState::InInteger
            case ParseState::InComment:
            {
                if (*state.TokenEnd == '
' || *state.TokenEnd == '#')
                {
                    state.State = ParseState::Begin;
                    if (*state.TokenEnd == '
')
                    {
                        lineNumber++;
                    }
                    columnNumber = 1;
                    PushToken(state, TokenType::Comment);
                }
                break;
            } //ParseState::InComment
            case ParseState::InIdentifier:
            {
                switch (*state.TokenEnd)
                {
                case'a':case'b':case'c':case'd':case'e':case'f':case'g':case'h':case'i':case'j':case'k':case'l':case'm':case'n':case'o':case'p':case'q':case'r':case's':
                case't':case'u':case'v':case'w':case'x':case'y':case'z':case'A':case'B':case'C':case'D':case'E':case'F':case'G':case'H':case'I':case'J':case'K':case'L':
                case'M':case'N':case'O':case'P':case'Q':case'R':case'S':case'T':case'U':case'V':case'W':case'X':case'Y':case'Z':case'_':
                {
                    break;
                }
                default:
                {
                    state.State = ParseState::Begin;
                    PushToken(state, TokenType::Identifier);
                    columnNumber--;
                    state.TokenEnd--;
                    break;
                }
                }
                break;
            } //ParseState::InIdentifier
            case ParseState::InString:
            {
                switch (*state.TokenEnd)
                {
                case '\':
                {
                    state.State = ParseState::InStringEscaping;
                    break;
                }
                case '"':
                {
                    state.State = ParseState::Begin;
                    PushToken(state, TokenType::String);
                    break;
                }
                case '
':
                {
                    throw std::exception("parse error in string");
                    break;
                }
                default:
                {
                    break;
                }
                }
                break;
            } // ParseState::InString
            case ParseState::InFloat:
            {
                switch (*state.TokenEnd)
                {
                case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':
                {
                    break;
                }
                default:
                {
                    PushToken(state, TokenType::Number);
                    columnNumber--;
                    state.TokenEnd--;
                    state.State = ParseState::Begin;
                    break;
                }
                }
                break;
            } //ParseState::InFloat
            case ParseState::InStringEscaping:
            {
                state.State = ParseState::InString;
                switch (*state.TokenEnd)
                {
                case'n':case'\':case'"':
                {
                    break;
                }
                default:
                {
                    throw std::exception("parse error in escaping");
                    break;
                }
                }
                break;
            } //ParseState::InStringEscaping
            } //switch state
            state.TokenEnd++;
            columnNumber++;
        }
        return tokenList;
    }
};

#endif // !TOKEN_STREAM

300行的大函数，我也是醉了