編譯器實現之旅——第四章 實現詞法分析器

在上一章的旅程中，咱們討論了詞法分析器的實現思路，咱們也爲詞法分析器的實現作了許多準備工做。如今，就讓咱們來實現詞法分析器吧。

1. 詞法分析器的類定義

詞法分析器的類定義以下：

class Lexer
{
public:

    // Constructor
    explicit Lexer(const string &inputFilePath);


    // NextToken
    Token NextToken();


    // Destructor
    ~Lexer();


private:

    // Attribute
    FILE *__filePtr;
    int __lineNo;


    // NextToken START Stage Dispatch
    void __nextTokenStartStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_ID Stage Dispatch
    void __nextTokenInIDStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_NUMBER Stage Dispatch
    void __nextTokenInNumberStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_DIVIDE Stage Dispatch
    void __nextTokenInDivideStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_COMMENT Stage Dispatch
    void __nextTokenInCommentStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken END_COMMENT Stage Dispatch
    void __nextTokenEndCommentStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_LESS Stage Dispatch
    void __nextTokenInLessStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_GREATER Stage Dispatch
    void __nextTokenInGreaterStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_ASSIGN Stage Dispatch
    void __nextTokenInAssignStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);


    // NextToken IN_NOT Stage Dispatch
    void __nextTokenInNotStage(int nowChar, bool &saveBool, LEXER_STAGE &lexerStage,
        TOKEN_TYPE &tokenType, string &tokenStr);
};

可見，詞法分析器的核心函數是NextToken，每次調用這個函數，詞法分析器都會返回下一個解析到的Token；爲了實現詞法分析器的各個狀態的不一樣行爲，咱們定義了多個分派函數；此外，咱們還定義了一個__lineNo變量，以記錄當前的行數，用於報錯信息中。

2. 構造函數和析構函數的實現

接下來，咱們來看看詞法分析器的構造函數和析構函數的實現：

Lexer::Lexer(const string &inputFilePath):
    __filePtr(fopen(inputFilePath.c_str(), "r")) {}


Lexer::~Lexer()
{
    fclose(__filePtr);
}

構造函數和析構函數的實現很簡單，這裏就不討論了。

3. NextToken函數的實現

接下來，咱們來看看詞法分析器最重要的NextToken函數的實現：

Token Lexer::NextToken()
{
    LEXER_STAGE lexerStage = LEXER_STAGE::START;
    TOKEN_TYPE tokenType;
    string tokenStr;

    while (lexerStage != LEXER_STAGE::DONE)
    {
        int nowChar = fgetc(__filePtr);
        bool saveBool = true;

        switch (lexerStage)
        {
            case LEXER_STAGE::START:
                __nextTokenStartStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_ID:
                __nextTokenInIDStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_NUMBER:
                __nextTokenInNumberStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_DIVIDE:
                __nextTokenInDivideStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_COMMENT:
                __nextTokenInCommentStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::END_COMMENT:
                __nextTokenEndCommentStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_LESS:
                __nextTokenInLessStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_GREATER:
                __nextTokenInGreaterStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_ASSIGN:
                __nextTokenInAssignStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;

            case LEXER_STAGE::IN_NOT:
                __nextTokenInNotStage(nowChar, saveBool, lexerStage, tokenType, tokenStr);
                break;
        }

        if (saveBool)
        {
            tokenStr += nowChar;
        }
    }

    return {tokenType, tokenStr, __lineNo};
}

在解析開始前，咱們首先將詞法分析器的狀態置爲「開始」狀態，而後不斷循環，直至詞法分析器的狀態變爲「完成」狀態。在循環體中，詞法分析器不斷讀入下一個字符，並利用一個saveBool布爾值保存當前讀入的這個字符是否須要被保存。接下來，根據詞法分析器的不一樣狀態，分別調用各個分派函數。這些分派函數均具備修改saveBool，lexerStage，tokenType，tokenStr這些變量的能力。當分派函數執行完畢後，若是saveBool仍是true，則將當前讀取到的字符加入記號字符串中。最終，咱們構造並返回一個Token。

接下來，咱們來看看各個分派函數的實現，首先從「開始」狀態的分派函數開始。

4. 「開始」狀態的分派函數的實現

__nextTokenStartStage函數用於在詞法分析器處於「開始」狀態時被調用，其實現以下：

void Lexer::__nextTokenStartStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    if (isalpha(nowChar))
    {
        lexerStage = LEXER_STAGE::IN_ID;
    }
    else if (isdigit(nowChar))
    {
        lexerStage = LEXER_STAGE::IN_NUMBER;
    }
    else if (isspace(nowChar))
    {
        saveBool = false;

        if (nowChar == '\n')
        {
            __lineNo++;
        }
    }
    else
    {
        switch (nowChar)
        {
            case '+':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::PLUS;
                break;

            case '-':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::MINUS;
                break;

            case '*':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::MULTIPLY;
                break;

            case '/':
                saveBool = false;
                lexerStage = LEXER_STAGE::IN_DIVIDE;
                break;

            case '<':
                lexerStage = LEXER_STAGE::IN_LESS;
                break;

            case '>':
                lexerStage = LEXER_STAGE::IN_GREATER;
                break;

            case '=':
                lexerStage = LEXER_STAGE::IN_ASSIGN;
                break;

            case '!':
                lexerStage = LEXER_STAGE::IN_NOT;
                break;

            case ';':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::SEMICOLON;
                break;

            case ',':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::COMMA;
                break;

            case '(':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::LEFT_ROUND_BRACKET;
                break;

            case ')':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::RIGHT_ROUND_BRACKET;
                break;

            case '[':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::LEFT_SQUARE_BRACKET;
                break;

            case ']':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::RIGHT_SQUARE_BRACKET;
                break;

            case '{':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::LEFT_CURLY_BRACKET;
                break;

            case '}':
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::RIGHT_CURLY_BRACKET;
                break;

            case EOF:
                lexerStage = LEXER_STAGE::DONE;
                tokenType = TOKEN_TYPE::END_OF_FILE;
                break;

            default:
                InvalidChar(nowChar, __lineNo);
                break;
        }
    }
}

「開始」狀態是整個詞法分析器中最複雜的狀態。在這個狀態下，詞法分析器可能會遇到並處理不少種狀況，列舉以下：

1. 若是當前讀取到的字符是一個字母，則詞法分析器應進入「正在讀取單詞」狀態
2. 同理，若是當前讀取到的字符是一個數字，則詞法分析器應進入「正在讀取數字」狀態
3. 若是當前讀取到的字符是一個空白符，則詞法分析器應停留在「開始」狀態，並丟掉當前讀取到的字符。特別的，若是當前讀取到的字符是一個換行符，則當前行數須要加1
4. 若是當前讀取到的字符是「+」、「-」、「*」、「;」、「,」、「(」、「)」、「[」、「]」、「{」、「}」或EOF這些僅由一個字符構成的記號，則咱們能夠當即肯定當前記號的類別，並令詞法分析器當即進入「完成」狀態
5. 若是當前讀取到的字符是「/」、「<」、「>」、「=」或「!」，則詞法分析器應進入各中間狀態
6. 若是當前讀取到的字符不知足上述各類狀況之一，則報錯退出

這裏須要額外說明的是，若是當前讀取到的字符是一個「/」，則咱們此時並不知道這個「/」需不須要被保存下來。咱們必須等到肯定這個「/」是一個除號時，再保存這個「/」，故此時，咱們須要將saveBool置爲false。

5. 「正在讀取單詞/數字」狀態的分派函數的實現

__nextTokenInIDStage與__nextTokenInNumberStage函數分別用於在詞法分析器處於「正在讀取單詞」和「正在讀取數字」狀態時被調用，其實現以下：

void Lexer::__nextTokenInIDStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    if (!isalpha(nowChar))
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        lexerStage = LEXER_STAGE::DONE;
        tokenType = KEYWORD_MAP.count(tokenStr) ? KEYWORD_MAP.at(tokenStr) : TOKEN_TYPE::ID;
    }
}


void Lexer::__nextTokenInNumberStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    if (!isdigit(nowChar))
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        lexerStage = LEXER_STAGE::DONE;
        tokenType = TOKEN_TYPE::NUMBER;
    }
}

當詞法分析器處於「正在讀取單詞」狀態時，若是當前讀取到的字符仍是一個字母，那麼此時什麼都不須要作（詞法分析器的狀態不變，saveBool也不變）；若是不是，則咱們知道：此時單詞已經讀完了，且很重要的一點是：當前讀取到的字符並不算在這個單詞內。因此，咱們須要將saveBool置爲false，並退回當前讀取到的字符至文件句柄；同時，咱們將詞法分析器的狀態置爲「完成」狀態；此外，咱們須要查閱關鍵詞表，以肯定當前讀取到的單詞是不是一個關鍵詞。

當詞法分析器處於「正在讀取數字」狀態時，狀況與「正在讀取單詞」狀態是幾乎一致的。惟獨不一樣的是，讀取數字時不須要進行關鍵詞斷定。

6. 「正在讀取除號」狀態的分派函數的實現

__nextTokenInDivideStage函數用於在詞法分析器處於「正在讀取除號」狀態時被調用，其實現以下：

void Lexer::__nextTokenInDivideStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    if (nowChar == '*')
    {
        saveBool = false;
        lexerStage = LEXER_STAGE::IN_COMMENT;
    }
    else
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        lexerStage = LEXER_STAGE::DONE;
        tokenType = TOKEN_TYPE::DIVIDE;
        tokenStr = "/";
    }
}

當詞法分析器已經讀取到了一個「/」後，其進入「正在讀取除號」狀態（請注意，此時的saveBool是false）。此時，若是又讀取到了一個「」，則詞法分析器應進入「正在讀取註釋」狀態；反之，若是讀取到的字符不是「」，咱們就能夠肯定：以前讀取到的「/」真的是一個除號。那麼咱們就須要退回當前讀取到的這個字符，而後將詞法分析器的狀態置爲「完成」狀態，並設定記號的類別和記號字符串。

7. 「正在讀取/逃離註釋」狀態的分派函數的實現

__nextTokenInCommentStage和__nextTokenEndCommentStage函數分別用於在詞法分析器處於「正在讀取註釋」和「正在逃離註釋」狀態時被調用，其實現以下：

void Lexer::__nextTokenInCommentStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    saveBool = false;

    if (nowChar == '*')
    {
        lexerStage = LEXER_STAGE::END_COMMENT;
    }
}


void Lexer::__nextTokenEndCommentStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    saveBool = false;

    if (nowChar == '/')
    {
        lexerStage = LEXER_STAGE::START;
    }
    else if (nowChar != '*')
    {
        lexerStage = LEXER_STAGE::IN_COMMENT;
    }
}

首先，不論是哪一個函數，只要和註釋搭邊了，saveBool都應置false。

正如上一章所說，當詞法分析器處於「正在讀取註釋」狀態時，其只但願看到「*」，若是看到了，則詞法分析器的狀態就應轉入「正在逃離註釋」狀態，不然，什麼都沒有變，詞法分析器將仍然處於「正在讀取註釋」狀態。

同理，當詞法分析器處於「正在逃離註釋」狀態時，若是其看到的是「/」，則詞法分析器就成功逃離了註釋，其狀態就回到了「開始狀態」；而若是其看到的仍是「*」，則詞法分析器將繼續停留在「正在逃離註釋」狀態；不然，很惋惜，詞法分析器應退回到「正在讀取註釋」狀態。

8. 「正在讀取小於號/大於號/等號/不等號」狀態的分派函數的實現

__nextTokenInLessStage、__nextTokenInGreaterStage、__nextTokenInAssignStage、__nextTokenInNotStage函數分別用於在詞法分析器處於「正在讀取小於號」、「正在讀取大於號」、「正在讀取等號」和「正在讀取不等號」狀態時被調用，其實現以下：

void Lexer::__nextTokenInLessStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    lexerStage = LEXER_STAGE::DONE;

    if (nowChar == '=')
    {
        tokenType = TOKEN_TYPE::LESS_EQUAL;
    }
    else
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        tokenType = TOKEN_TYPE::LESS;
    }
}


void Lexer::__nextTokenInGreaterStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    lexerStage = LEXER_STAGE::DONE;

    if (nowChar == '=')
    {
        tokenType = TOKEN_TYPE::GREATER_EQUAL;
    }
    else
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        tokenType = TOKEN_TYPE::GREATER;
    }
}


void Lexer::__nextTokenInAssignStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    lexerStage = LEXER_STAGE::DONE;

    if (nowChar == '=')
    {
        tokenType = TOKEN_TYPE::EQUAL;
    }
    else
    {
        saveBool = false;
        ungetc(nowChar, __filePtr);
        tokenType = TOKEN_TYPE::ASSIGN;
    }
}


void Lexer::__nextTokenInNotStage(int nowChar, bool &saveBool,
    LEXER_STAGE &lexerStage, TOKEN_TYPE &tokenType, string &tokenStr)
{
    if (nowChar == '=')
    {
        lexerStage = LEXER_STAGE::DONE;
        tokenType = TOKEN_TYPE::NOT_EQUAL;
    }
    else
    {
        InvalidChar(nowChar, __lineNo);
    }
}

這幾個函數的實現思路都是一致的，其均用於處理相似於：當前記號是一個「<」仍是一個「<=」的矛盾。咱們不妨以「正在讀取小於號」爲例，來看看這幾個函數的實現。

當詞法分析器已經讀取到了一個「<」後，其進入「正在讀取小於號」狀態。在此狀態下，不管當前讀取到的字符是什麼，詞法分析器都必定會進入「完成」狀態。咱們只須要看看當前讀取到的字符是否是一個「=」，若是是，則咱們就讀取到了一個「<=」；若是不是，則咱們就只是讀取到了一個「<」，和前面同樣，此時咱們須要置saveBool爲false，並退回當前讀取到的字符。

略有不一樣的是，當詞法分析器讀取到一個「!」，而後進入「正在讀取不等號」狀態後，其必須繼續讀取到一個「=」，以構成「!=」；而若是此時讀取到的字符並非「=」，則將被認爲是一個語法錯誤。

至此，「前端中的前端」——詞法分析器，就已經所有實現完成了。接下來，咱們須要爲實現編譯器前端的第二個組件——語法分析器作準備。請看下一章：《實現語法分析器前的準備》。