c++暴力实现的词法分析器

最新推荐文章于 2024-03-30 10:07:31 发布
最新推荐文章于 2024-03-30 10:07:31 发布
阅读量115 收藏
点赞数
分类专栏： 简易编译器实现 文章标签： c++ 编辑器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/idcardq/article/details/130391263
版权
该代码实现了一个简单的TokenStream类，用于解析包含编程语言元素的字符串，如关键字、标识符、数字、运算符和分隔符。它能识别常见的编程关键字并转换为对应的枚举值，支持处理字符串和注释，并能生成Token序列。
摘要由CSDN通过智能技术生成 
// Copyright 2023, liserver. All rights reserved.

#include "TokenStream.h"

const char Keyword[][20] = {
    "if",
    "else",
    "while",
    "for",
    "return",
    "break",
    "continue",
    "int",
    "float",
    "double",
    "string",
    "function",
    "switch",
    "case",
    "default",
    "class",
    "public",
    "private",
    "protected"};

TokenCode TokenType(Token token)
{
    return TokenCode::TK_NOT_DEFINED;
}

bool IsKeyword(std::string str)
{
    for (int i = 0; i < sizeof(Keyword) / sizeof(Keyword[0]); i++)
    {
        if (str == Keyword[i])
            return true;
    }
    return false;
}

int KeywordCode(std::string str)
{
    for (int i = 0; i < sizeof(Keyword) / sizeof(Keyword[0]); i++)
    {
        if (str == Keyword[i])
            return i + 1;
    }
    return -1;
}

bool IsChar(char c)
{
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
}

bool IsNumber(char c)
{
    return c >= '0' && c <= '9';
}

TokenStream ReadString(std::string str)
{
    std::vector<Token> tokens;
    Token token;
    int i = 0;
    while (i < str.length())
    {
        // Space
        if (str[i] == '\t' || str[i] == '\n' || str[i] == ' ')
        {
            if (str[i] == '\n')
                token.line++;
            i++;
            continue;
        }
        // Identifier
        else if (IsChar((char)str[i]))
        {
            while (IsChar((char)str[i]) && !IsNumber((char)str[i]))
            {
                token.value += str[i];
                i++;
            }
            if (IsKeyword(token.value))
            {
                token.code = TokenCode(KeywordCode(token.value));
            }
            else
            {
                token.code = TokenCode::TK_IDENTIFIER;
            }
        }
        // Number
        else if (IsNumber((char)str[i]))
        {
            int DoubleNumber = 0;
            while (IsNumber((char)str[i]))
            {
                token.value += str[i];
                i++;
            }
            if (str[i] == '.')
            {
                token.value += str[i];
                i++;
                while (IsNumber((char)str[i]))
                {
                    token.value += str[i];
                    i++;
                }
                token.code = TokenCode::TK_LITERAL_DOUBLE;
            }
            else
            {
                token.code = TokenCode::TK_LITERAL_INT;
            }
        }
        // Operator
        else
            switch (str[i])
            {
            case '$':
                while (str[i] != '\n')
                {
                    i++;
                }
                i++; // 指针指向下一行，节省一次循环
                break;
            case '+':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_ADD_ASSIGN;
                    token.value = "+=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_ADD;
                    token.value = "+";
                    i++;
                }
                break;
            case '-':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_SUB_ASSIGN;
                    token.value = "-=";
                    i += 2;
                }
                else if (str[i + 1] == '>')
                {
                    token.code = TokenCode::TK_OPERATOR_ARROW;
                    token.value = "->";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_SUB;
                    token.value = "-";
                    i++;
                }
                break;
            case '*':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_MUL_ASSIGN;
                    token.value = "*=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_MUL;
                    token.value = "*";
                    i++;
                }
                break;
            case '/':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_DIV_ASSIGN;
                    token.value = "/=";
                    i += 2;
                }
                else if (str[i + 1] == '/')
                {
                    i += 2;
                    // 单行注释
                    while (str[i] != '\n')
                        i++;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_DIV;
                    token.value = "/";
                    i++;
                }
                break;
            case '%':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_MOD_ASSIGN;
                    token.value = "%=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_MOD;
                    token.value = "%";
                    i++;
                }
                break;
            case '=':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_EQUAL;
                    token.value = "==";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_ASSIGN;
                    token.value = "=";
                    i++;
                }
                break;
            case '!':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_NOT_EQUAL;
                    token.value = "!=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_NOT;
                    token.value = "!";
                    i++;
                }
                break;
            case '>':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_GREATER_EQUAL;
                    token.value = ">=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_GREATER;
                    token.value = ">";
                    i++;
                }
                break;
            case '<':
                if (str[i + 1] == '=')
                {
                    token.code = TokenCode::TK_OPERATOR_LESS_EQUAL;
                    token.value = "<=";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_OPERATOR_LESS;
                    token.value = "<";
                    i++;
                }
                break;
            case '&':
                if (str[i + 1] == '&')
                {
                    token.code = TokenCode::TK_OPERATOR_AND;
                    token.value = "&&";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_NOT_DEFINED;
                    token.value = "&";
                    i++;
                }
                break;
            case '|':
                if (str[i + 1] == '|')
                {
                    token.code = TokenCode::TK_OPERATOR_OR;
                    token.value = "||";
                    i += 2;
                }
                else
                {
                    token.code = TokenCode::TK_NOT_DEFINED;
                    token.value = "|";
                    i++;
                }
                break;
            // 分隔符
            case '(':
                token.code = TokenCode::TK_DELIMITER_LEFT_PARENTHESIS;
                token.value = "(";
                i++;
                break;
            case ')':
                token.code = TokenCode::TK_DELIMITER_RIGHT_PARENTHESIS;
                token.value = ")";
                i++;
                break;
            case '{':
                token.code = TokenCode::TK_DELIMITER_LEFT_BRACE;
                token.value = "{";
                i++;
                break;
            case '}':
                token.code = TokenCode::TK_DELIMITER_RIGHT_BRACE;
                token.value = "}";
                i++;
                break;
            case '[':
                token.code = TokenCode::TK_DELIMITER_LEFT_BRACKET;
                token.value = "[";
                i++;
                break;
            case ']':
                token.code = TokenCode::TK_DELIMITER_RIGHT_BRACKET;
                token.value = "]";
                i++;
                break;
            case ',':
                token.code = TokenCode::TK_DELIMITER_COMMA;
                token.value = ",";
                i++;
                break;
            case ';':
                token.code = TokenCode::TK_DELIMITER_SEMICOLON;
                token.value = ";";
                i++;
                break;
            case '.':
                token.code = TokenCode::TK_DELIMITER_DOT;
                token.value = ".";
                i++;
                break;
            case ':':
                token.code = TokenCode::TK_DELIMITER_COLON;
                token.value = ":";
                i++;
                break;
            case '"':
            {
                std::string tempstra = "";
                int temp = 0;
                while (str[i + 1] != '"' && i < str.size() && str[i + 1] != '\n')
                {
                    tempstra += str[i + 1];
                    temp++;
                    i++;
                }
                if (str[i + 1] != '"')
                {
                    token.code = TokenCode::TK_NOT_DEFINED;
                    token.value = "\"";
                    i -= temp - 1;
                }
                else
                {
                    token.code = TokenCode::TK_LITERAL_STRING;
                    token.value = tempstra;
                    i += 2;
                }
                break;
            }
            default:
                token.code = TokenCode::TK_NOT_DEFINED;
                token.value = str[i];
                i++;
                break;
            }
        if (token.code != TokenCode::TK_LITERAL_STRING && token.value == "")
            continue;
        tokens.push_back(token);
        token.value = "";
        token.code = TK_NOT_DEFINED;
    }

    // Save and return
    return TokenStream(tokens);
}

TokenStream.h：

// Copyright 2023, liserver. All rights reserved.

#pragma once

#include <iostream>
#include <string>
#include <vector>

#include "../Compiler.h"

enum TokenCode
{
    // About Token
    TK_NOT_DEFINED = 0, // Not defined

    // Keywords
    TK_KEYWORD_IF,        // if
    TK_KEYWORD_ELSE,      // else
    TK_KEYWORD_WHILE,     // while
    TK_KEYWORD_FOR,       // for
    TK_KEYWORD_RETURN,    // return
    TK_KEYWORD_BREAK,     // break
    TK_KEYWORD_CONTINUE,  // continue
    TK_KEYWORD_INT,       // int
    TK_KEYWORD_FLOAT,     // float
    TK_KEYWORD_DOUBLE,    // double
    TK_KEYWORD_STRING,    // string
    TK_KEYWORD_FUNCTION,  // function
    TK_KEYWORD_SWITCH,    // switch
    TK_KEYWORD_CASE,      // case
    TK_KEYWORD_DEFAULT,   // default
    TK_KEYWORD_CLASS,     // class
    TK_KEYWORD_PUBLIC,    // public
    TK_KEYWORD_PRIVATE,   // private
    TK_KEYWORD_PROTECTED, // protected

    // Operators
    TK_OPERATOR_ADD,           // +
    TK_OPERATOR_SUB,           // -
    TK_OPERATOR_MUL,           // *
    TK_OPERATOR_DIV,           // /
    TK_OPERATOR_MOD,           // %
    TK_OPERATOR_ASSIGN,        // =
    TK_OPERATOR_ADD_ASSIGN,    // +=
    TK_OPERATOR_SUB_ASSIGN,    // -=
    TK_OPERATOR_MUL_ASSIGN,    // *=
    TK_OPERATOR_DIV_ASSIGN,    // /=
    TK_OPERATOR_MOD_ASSIGN,    // %=
    TK_OPERATOR_EQUAL,         // ==
    TK_OPERATOR_NOT_EQUAL,     // !=
    TK_OPERATOR_LESS,          // <
    TK_OPERATOR_LESS_EQUAL,    // <=
    TK_OPERATOR_GREATER,       // >
    TK_OPERATOR_GREATER_EQUAL, // >=
    TK_OPERATOR_ARROW,         // ->
    TK_OPERATOR_AND,           // &&
    TK_OPERATOR_OR,            // ||
    TK_OPERATOR_NOT,           // !

    // Delimiters
    TK_DELIMITER_LEFT_BRACE,        // {
    TK_DELIMITER_RIGHT_BRACE,       // }
    TK_DELIMITER_LEFT_BRACKET,      // [
    TK_DELIMITER_RIGHT_BRACKET,     // ]
    TK_DELIMITER_LEFT_PARENTHESIS,  // (
    TK_DELIMITER_RIGHT_PARENTHESIS, // )
    TK_DELIMITER_COMMA,             // ,
    TK_DELIMITER_SEMICOLON,         // ;
    TK_DELIMITER_DOT,               // .
    TK_DELIMITER_COLON,             // :

    // Literals
    TK_LITERAL_INT,    // 123
    TK_LITERAL_FLOAT,  // 123.456
    TK_LITERAL_DOUBLE, // 123.456
    TK_LITERAL_STRING, // "Hello World"

    // Token IDENTIFIER
    TK_IDENTIFIER // identifier
};

class Token
{
public:
    TokenCode code = TokenCode::TK_NOT_DEFINED;
    std::string value = "";
    int line = 1;
};

// 对于Token，每一个一连串的字符都是一个Token
// 例如：123.456是一个Token，"Hello World"是一个Token

// 判断是否是一个关键字
bool IsKeyword(std::string str);

// 返回关键字的ID
int KeywordCode(std::string str);

// 判断是否是一个字符
bool IsChar(char c);

// 判断是否是一个数字
bool IsNumber(char c);

// 首先读取给定字符串每一个字符，如果是空格或者换行符，储存当前Token，然后继续读取下一个字符

TokenCode TokenType(Token token);

class TokenStream
{
public:
    int number = 0; // 当前Token的序号
    std::vector<Token> tokens;
    inline int Size()
    {
        return tokens.size();
    }
    TokenStream(){};

    TokenStream(std::vector<Token> tokens)
    {
        this->tokens = tokens;
    }
    Token Up()
    {
        if (this->number > 0)
        {
            this->number -= 1;
            return this->tokens[this->number];
        }
        else
        {
            this->number = this->tokens.size() - 1;
            return this->tokens[this->number];
        }
    }
    Token Next()
    {
        if (number < Size())
        {
            Token token = this->tokens[this->number];
            this->number += 1;
            return token;
        }
        else
        {
            this->number = 0;
            return this->tokens[this->number];
        }
    }
    inline std::vector<Token> GetVector()
    {
        return this->tokens;
    }
};

TokenStream ReadString(std::string str);

liserver
关注
专栏目录
C++实现词法分析器.zip
06-09
在这个名为"C++实现词法分析器"的实验中，我们将深入理解词法分析的原理，并学习如何使用C++来构建一个词法分析器。 词法分析的目的是将源代码文本转换为一系列的标记，这些标记通常包括关键字、标识符、常量、...
词法分析器（c++）
yizhizhazhahui的博客
11-27 6297
c++，编译原理实验，词法分析器
C++实现简单词法分析器lexer
Tea_Char的博客
04-07 621
c++实现简单词法分析器
词法分析器C++实现
hjy9494的博客
03-03 1276
编译原理词法分析器
简单词法分析器——C++实现 （编译原理作业）
qq_53485165的博客
04-18 5616
词法分析器——C++实现 单词符号表示 （1）标识符：以字母开头的包含字母和数字的符号 （2）保留字：while、if、else、switch、case （3）常数：数字0~9 （4）运算符：+、-、*、<、<=、==、= （5）界符：； （6）需略除的：空格、制表符、换行符 主要函数 concatenation() //连接token和character中字符作为token中新的字符串 letter ()//判断是否字母 digit() //判断是否数字 reserve() //按照tok
C++实现简易PL/0词法分析器
qq_57495370的博客
04-16 3211
总之，词法分析是编译器中的一个重要组成部分，它负责将输入流中的字符序列分解成一个一个的单词，为后续的语法分析和代码生成等工作提供了基础。本文介绍了一个简单的词法分析器程序，它可以帮助我们更好地理解程序的输入解析过程，也可以作为其他编译器程序的基础组件进行扩展和优化。在本程序中，还定义了一个关键字列表，用于判断是否为关键字。输出文件中的每一行都表示一个单词，其中括号内的第一个值表示单词的类型，第二个值表示单词的值。此外，程序还提供了一个函数，用于在控制台输出输入文件的内容，以便我们更好地了解程序的输入数据。
基于C++实现词法分析器
06-28
用C或C++语言编写一个简单的词法分析程序，扫描C语言小子集的源程序，根据给定的词法规则，识别单词，填写相应的表。如果产生词法错误，则显示错误信息、位置，并试图从错误中恢复。简单的恢复方法是忽略该词法单元...
基于C++简单实现词法分析器【100011993】
04-25
设计、编制并调试一个简单语言 CP(Compiler Principle)的词法分析程序，加深对词法分析原理的理解。 实验内容 CP 语言的词法 (1) 关键词： begin end if then else for while do and or not 注意：所有关键词都是...
C++实现词法分析器
08-26
C++实现词法分析器 C++实现词法分析器是编译原理中的一种基本技术，用于将源代码分解成一个个的token，以便后续的语法分析和语义分析。本文将详细介绍C++实现词法分析器的相关代码，并对关键技术进行解释。 词法...
编译原理 词法分析器 c++实现
12-05
参考附录C.1设计一个简单语言的词法分析程序，要求能够处理换行回车、注释（自定义注释格式）、部分符合运算符（如>= 、 等）。 注意： 附录C.1采用的是控制台输入输出的方式，测试数据要用文本文件保存好。
编译原理——词法分析器 C++实现
weixin_45693492的博客
04-12 2万+
词法分析器实验目的单词分类表单词结构描述单词状态转换图算法描述程序结构源代码实验结果 实验目的 对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状态转换图设计词法分析器的基本方法。利用该词法分析器完成对源程序字符串的词法分析。 培养团队合作精神，体会协同工作在解决问题中的作用。 单词分类表 单词符号 种类 种别码 单词符号 种类 种别码 未定义符号 未定义符号 0 =...
编译原理——词法分析器（C/C++代码实现）
qq_58773908的博客
01-01 4769
编译原理实验：实验一：词法分析器编写识别单词的词法分析器，控制台输出识别出的每个单词。内含实验代码。实验报告下载链接。
【编译原理】词法分析：C/C++实现
热门推荐
朝花夕拾
11-04 2万+
这篇史上最全的编译原理之词法分析实验讲解绝对是您的不二选择！汇总了无数专业知识，详解万字，覆盖面广泛，解释细致入微，确保您轻松理解并掌握词法分析的方方面面。无需再寻觅其他资料，只需收藏这一篇，您便能轻松掌握词法分析的精髓，提升编译原理的理解水平，事半功倍，不容错过！
编译原理词法分析器的c++实现
weixin_42529594的博客
04-19 5694
一、题目的理解和说明 编译原理这门课是计算机专业的核心课程之一，是一门研究软件是什么，为什么可以运行，以及怎么运行的学科。编译系统的改进将会直接对其上层的应用程序的执行效率，执行原理产生深刻的影响。编译原理的目的是将源语言翻译成目标语言。其过程分为词法分析、语法分析、语义分析中间代码生成、中间代码优化、代码生成等五个阶段。而本次实验所解决的问题是编译程序的第一个阶段–词法分析。 实验要求实现一个可...
编译原理---词法分析器的简单实现(c++)
weixin_43919032的博客
04-05 4784
什么是词法分析器 简单来说，词法分析器，就是将用户输入的代码（一个个字符）通过某种方式拼接成有意义的一个个字符片段，什么是有意义呢？不同语言的定义不太相同，但大体来说，有意义表示这五类：关键字、标识符、数字串、运算符和分隔符、空白字符。拼接的方式多种多样，可以使用DFA也可以单纯的进行字符的拼接。 大致思路 这里就使用字符的拼接，由于这个程序比较简单，就每次判断下一个字符是字母、数字或者下划...
C++-c语言词法分析器
MoOtA
04-15 2433
特别的，在预处理阶段，识别单/多行注释时，遇到了一个小问题，由于要支持字符串常量和字符常量，而该常量中可能包含//，/*，导致将字符串内容识别为注释，另外，由于需要支持转义字符‘\’的存在，正确识别的字符串，也成为了一大问题，在多次修改匹配代码后，终于将问题解决。无符号十六进制整型常量，正规式为： 0(X|x)(0-9|a-f|A-F)*赋值运算符 += -= *= /= %= = &= ^= |=实验要求：无符号十进制整型常量，正规式为：(1-9)(0-9)*
c++按照指定的分隔符分割字符串
最新发布
qq_27390023的博客
03-30 535
是 C++ 标准库中的一个类，定义在头文件中，用于从字符串中进行输入操作。它允许你像使用std::cin一样从字符串中提取数据，并进行解析。
词法分析器 【编译原理】C++实现}
sddya的博客
05-24 5080
通过文件输入输出
C++实现词法分析器详解
"本资源提供了一个使用C++实现的词法分析器的示例，它涉及到编译原理中的词法分析阶段。代码清晰易懂，适用于理解C语言的词法分析过程。词法分析器主要任务是识别源代码中的标识符（ID）、数字（NUM）、运算符（OP）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值