编译原理实验：词法分析（C++）

已于 2024-08-14 13:43:49 修改
阅读量780 收藏 17
点赞数 10
文章标签： c++ 开发语言
于 2024-08-14 13:35:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38304433/article/details/141188208
版权

当时为了各模块之间分明，我的标识符识别和词法分析函数细看是有些冗余的，之后写完后怕麻烦就没做修改，你可以试着把标识符和词法分析那两个函数结合一下，直接在标识符识别里面完成词法分析的要求都行。代码中我的注释应该也挺清晰的。

目录

        1.预处理

        2.标识符的识别

        3.词法分析

        4.代码展示

        5.读取文件和运行结果

        6.附录

1.预处理

【任务介绍】在词法分析之前，对程序员提交的源程序进行预处理，剔除注释等不必要的字符，以简化词法分析的处理

【输入】字符串形式的源程序。

【输出】处理之后的字符串形式的源程序。

【题目】设计一个程序，从任意字符串中剔除C语言形式的注释，包括：

        （1）形如： //…的单行注释；

        （2）形如： /*…*/ 的多行注释。

2.标识符的识别

【任务介绍】根据给定源语言的构词规则，从任意字符串中识别出所有的合法标识符。

【输入】字符串。

【输出】单词符号流，一行一个单词。

【题目】设计一个程序，从任意字符串中识别出所有可视为C语言“名字”的子串。注意：

          （1）构词规则：以字母打头，后跟任意多个字母、数字的单词；长度不超过15；不区分大小写；把下划线 视为第27个字母。

          （2）关键字保留，即：语言定义中保留了某些单词用作关键字，同学们不可以将这些单词用作“名字“（变量名、常量名、函数名、标号名等等）。

3.词法分析

【任务介绍】根据给定源语言的构词规则，从任意字符串中识别出该语言所有的合法的单词符号，并以等长的二元组形式输出。

【输入】字符串形式的源程序。

【输出】单词符号所构成的串（流），单词以等长的二元组形式呈现。

【题目】设计一个程序，根据给定源语言的构词规则，从任意字符串中识别出该语言所有的合法的单词符号，并以等长的二元组形式输出。注意：

        （1）附录A中介绍了一个基于C语法规则设计的源语言LittleC（我使用的）和一个基于Pascal语法规则设计的源语言LittleP，可以作为参考。

        （2）同学们可以自行挑选或设计一种源语言，以此为基础来完成本实验和后续实验。该语言的设计应该满足附录B的要求。

        （3） 该程序应该设计为至少包含2个模块：驱动模块和工作模块。驱动模块包含了程序的入口和出口，主要负责输入、输出处理并调用工作模块；工作模块负责具体的分割、识别、归类等工作。这样做的好处是：只要模块间的接口（需要传递哪些数据，数据的结构）设计合理，后续实验中做语法分析器时就可以直接调用此处的工作模块，而不需要改动太多代码。

4.代码展示

注：所调用的文件内容为C语言所写（就是input.txt里面的内容），且调用的文法里面只需要包含下述的那些三种关键字，运算符，分隔符即可，详细的解释我写在代码中写了哦。

#include <iostream>
#include <fstream>
#include <queue>
#include <algorithm> // 包含 std::find
#include <cstring>
using namespace std;


// 词法分析表
struct Analysis {    
    int type;             // 类型编号
    string array;        // 实际存储
};
Analysis a_struct[1024];


//可识别的C语言的关键字全局变量
static char keywords[4][6] = { "int","if","else","while"};

//可识别的C语言的运算符全局变量
static char operators[11][3] = { "+", "-", "*", "/", "=", ">", "<", ">=", "<=", "==", "!=" };
//可识别的C语言的分隔符全局变量
static char delimiters[6] = { '{', '}', '(', ')', ',', ';'};  //分隔符,共6个


//调用的函数模块
void preprocess(ifstream& fin, ofstream& fout);
void recognize_identifier(char space1[], int count);
void Lexical_analysis(char (&temp)[1024][30]);


int main() {
    ifstream fin("input.txt");
    ofstream fout("output.txt");
    if (!fin.is_open() || !fout.is_open()) {
        cout << "文件不存在!";
        return 0;
    }

    preprocess(fin, fout);
    fin.close();
    fout.close();

    return 0;

}


//预处理操作
void preprocess(ifstream& fin, ofstream& fout) {
    char total[1024] = { '\0' }, a, b; // a为读取的第一个字符，b为a之后的字符
    fin.read(total, sizeof(total)); // 将文件读取到的原始内容存入total数组
    int count = fin.gcount(); // the total number of characters read from the file
    int count1 = count;
    char space1[1024] = { '\0' }; // 初始化为全零，将初始化的文件内容存入space1数组中
    int i = 0, j = 0;
    int number = 0; // 进行选择判断：0为无注释；1为单行注释；2为多行注释
    bool in_quotes = false; // 是否在引号内部的标志

    while (count > 0) { 
        a = total[i];
        b = total[i + 1];
        // if(i == count1){

        // }
        // 检查是否在引号内
        if (a == '\'' || a == '\"') {
            in_quotes = !in_quotes;
        }

        if (!in_quotes) {
            switch (number) {
            case 0:
                if (a == '/' && b == '/') {
                    number = 1;
                }
                else if (a == '/' && b == '*') {
                    if (total[i + 2] == '/')//当遇见"/*/"类型，i再递增一位即可
                    {
                        i++;
                    }
                    number = 2;
                }
                else {
                    space1[j++] = total[i]; // 将字符存入 space1 数组中，并递增 j
                }
                break;
            case 1:
                if (total[i] == '\n') {
                    number = 0;
                    space1[j++] = '\n'; // 单行注释结束后加入换行符
                }
                break;
            case 2:
                if (a == '*' && b == '/') {
                    number = 0;
                    i += 1;
                }
                break;
            }
        }
        else {
            space1[j++] = total[i]; // 将字符存入 space1 数组中，并递增 j
        }

        i++; // 将 i 的递增放在循环内部
        count--;

    }
    /*出现一个问题，这个代码如果在VS里面运行，不会出现最后会多一个字符，但是在vscode里面就会出现，暂直接将末尾置空*/
    j--;
    space1[j] = '\0';

    //cout<< space1<<endl;
    fout << space1; // 输出 space1 中的内容
    recognize_identifier(space1, count1); // 进行标识符的识别
    
}


//标识符识别
/*首先建立一个队列，有栈顶栈底指针，每次遇到空格、换行符或其他不合法字符就出栈，将出队列的数据存入另一个基本数组；
  然后对得到的基本数组进行判断，看是否它的属于关键字与长度是否符合要求，是否属于正规标识符，然后合法就输出。
*/

// 外置函数，用于处理队列中的元素（只是在下列标识符识别中多次使用，为简洁，所以单独提出）
void ProcessQueueItems(queue<char>& q1, char temp[1024][30], int& j, int& num1, int& num) {
    for (; num > 0; num--) {
        temp[j][num1++] = q1.front();//始终保持以队列的首部值存入temp数组中
        q1.pop();//将队列中的值逐个出队
    }
    j++;
    num1 = 0;
    num = 0;
}

void recognize_identifier(char space1[1024], int count) {
    ofstream fout1("output_identifier.txt");//此文件为第二个输出文件（主要保存输出的合法标识符）
    queue<char>q1;
    space1[count] = { '\0' };//在space1的末尾再加上0用来保证下面循环的正常运行；
    char temp[1024][30] = { '\0' };//用来存储粗略划分标识符的结果（处理完的结果包含五种，未进行筛选）
    int i = 0, j = 0, num = 0, num1 = 0;
    int flag = 0, flag1 = 0;

    char op[8] = { '+', '-', '*', '/', '=', '>', '<','!' };

    //粗略建立标识符数组
    while (count >= 0) {
        if (space1[i] != ' ' && space1[i] != '\n') {
            //首先判断是否为关键字和标识符和数字
            if (isalpha(space1[i]) || isdigit(space1[i]) || (space1[i] == '_') || space1[i] == '\0') {
                if ((q1.size() != '\0') && ((space1[i] == '\0') || flag == 1)) {//前半部分主要保证最后一次有效读入的队列中还有值但space[i]中的i值已指向无效空值时；其余都使用flag作为判断条件
                    ProcessQueueItems(q1, temp, j, num1, num); // 调用外置函数
                }
                else {
                    q1.push(space1[i]);//将值入队
                    flag = 0;
                    num++;
                    i++;
                    count--;
                }
            }
            //是否为分隔符,是的话进入
            else  if (find(begin(delimiters), end(delimiters), space1[i]) != end(delimiters)) {//这个就是比对一维数组delimiters与当前字符是否有相同的值，有的话进入
                if (q1.size() != '\0') {//此处再一次判断是为了保证遇到分隔符之后队列中有值能够先存入temp,因为下列i值会增加，导致队列还未出队，便已经开始存入新值
                    ProcessQueueItems(q1, temp, j, num1, num); // 调用外置函数
                }
                temp[j++][0] = space1[i];
                i++;
                count--;
                flag = 1;
            }
            //是否为运算符，是的话进入
            else  if (find(begin(op), end(op), space1[i]) != end(op)) {
                if (q1.size() != '\0') {
                    ProcessQueueItems(q1, temp, j, num1, num); // 调用外置函数
                }
                //下列if为双值运算符 ">=" "<=" "==" "!=" 之后若有新运算符需添加，修改下列判断条件即可
                if ((space1[i] == '>' && space1[i + 1] == '=') || (space1[i] == '<' && space1[i + 1] == '=') || (space1[i] == '=' && space1[i + 1] == '=') || (space1[i] == '!' && space1[i + 1] == '=')) {
                    temp[j][0] = space1[i++];
                    temp[j++][1] = space1[i++];
                    count -= 2;//一次存入两个字符所以减2
                }
                else {
                    //此为单个运算符
                    temp[j++][0] = space1[i++];
                    count--;
                }
                flag = 1;
            }
            else if (space1[i] == '"'|| space1[i] == '\'') {//遇见单双引号识别为字符串常量，直到遇见下一个相对应的单双引号跳出
                while (1) {
                    count--;
                    i++;
                    if (space1[i] == '"' || space1[i] == '\'') {
                        break;
                    }
                }
                i++;
                count--;
            }
            else  {//不属于上述的要求的字符值
                i++;
                count--;
                if (q1.size() != '\0') {
                    ProcessQueueItems(q1, temp, j, num1, num); // 调用外置函数
                }
            }
        }
        else {
            i++;
            count--;
            flag = 1;
        }
    }

    int num2 = j;//num2:为了在下述循环中得到循环次数
    //判断是否为合法字符串
    //去除关键字
    int count1 = 0;//计数
    for (int j = 0;j < num2;j++) {
        for (int i = 0;i < 4;i++)
        {
            if (strcmp(keywords[i], temp[j]) == 0)//当遇到相同关键字时，直接跳出当前循环导致count1<4
            {
                break;
            }
            count1++;
        }
        //去除数字和长度不符的标识符
        if (count1 == 4 && (strlen(temp[j]) <= 15 && (isalpha(temp[j][0]) || (temp[j][0] == '_'))))//只有count1=4且temp中字符串的大小小于15且temp的首字符符合判断要求
        {
            cout << temp[j] << endl;
            fout1 << temp[j] << endl;

        }
        count1 = 0;
    }
    fout1.close();
    Lexical_analysis(temp);//进行词法分析，传入的是未进行详细划分的数组（5种类型都包含在内）
}

//词法分析
void Lexical_analysis(char (&temp)[1024][30]) {
    ofstream fout2("output_binary.txt");//此文件为第二个输出文件（主要保存输出的合法二元组）
    char op[8] = { '+', '-', '*', '/', '=', '>', '<','!' };
    string temp1[1024]; // 假设字符串数组的大小为1024
    for (int i = 0; i < 1024; i++) {
        temp1[i] = temp[i];
    }
    int i = 0, number = 1;
    int a_count = 0;
    while (temp[i][0]!='\0') {   
        switch (number) {
            //判断为关键字
        case 1:
            for (int j = 0;j < 4;j++)
            {
                if (strcmp(keywords[j], temp[i]) == 0)//当遇到相同关键字时，直接跳出当前循环
                {
                    a_struct[a_count].type = 1;//type:1 
                    //strcpy_s(a_struct[a_count++].array, temp[i++]);//这个是char类型之间的 
                    a_struct[a_count++].array = temp1[i++];//只有当识别到为关键字时，i++,保证case5不会重复读入
                    break;//因为此break只跳出的是for循环，仍会逐一进行case2/3/4/5,当在case5时，若没有上面的i++，则仍会再次存入相同的关键字！
                }
            }
            //判断为运算符
        case 2:
            if (find(begin(op), end(op), temp[i][0]) != end(op)) {
                a_struct[a_count].type = 2;//type:2
                //strcpy_s(a_struct[a_count++].array, temp[i]);
                a_struct[a_count++].array = temp1[i];
                break;
            }
           
            //判断为分隔符
        case 3:
            if (find(begin(delimiters), end(delimiters), temp[i][0]) != end(delimiters)) {
                a_struct[a_count].type = 3;//type:3
                //strcpy_s(a_struct[a_count++].array, temp[i]);
                a_struct[a_count++].array = temp1[i];
                break;
            }
            //判断为数字
        case 4:
            if (isdigit(temp[i][0])) {
                a_struct[a_count].type = 4;//type:4
                //strcpy_s(a_struct[a_count++].array, temp[i]);
                a_struct[a_count++].array = temp1[i];
                break;
            }
            //判断为标识符
        case 5:
            a_struct[a_count].type = 5;//type:5
            //strcpy_s(a_struct[a_count++].array, temp[i]);
            a_struct[a_count++].array = temp1[i];
            break;
        }
        i++;
    }
    for (int i =0;i < a_count;i++) {
        fout2 << "( " << a_struct[i].type << " , " << a_struct[i].array << " )"<<endl;
        cout << "( " << a_struct[i].type << " , " << a_struct[i].array << " )"<<endl;
    }
}
5.读取文件和运行结果

（1）读取文件（input.txt 未处理）

（2）预处理之后的输出文件

（3）标识符识别的输出文件

（4）二元组输出文件（未展示全部，太长了（>_<））

6.附录

（1）文法定义

PROG→BLOCK

BLOCK→{ DECLS  STMTS }

DECLS→DECLS  DECL | empty

DECL→TYPE  NAMES ;

TYPE→int

NAMES→NAMES ,  NAME | NAME

NAME→id

STMTS→STMTS  STMT | empty

STMT→id = EXPR ;

STMT→if ( REL ) STMT

STMT→if ( REL ) STMT else STMT

STMT→while ( REL ) STMT

STMT→BLOCK

EXPR→EXPR ADD TERM | TERM

ADD→+ | -

TERM→TERM MUL FACTOR | FACTOR

MUL→* | /

FACTOR→( EXPR) | id | number

REL→EXPR  ROP  EXPR

ROP→ > | >= | < | <= | == | !=


（2）词法规则

        1）名字：由字母打头后跟字母、数字任意组合的字符串；长度不超过15；不区分大小写；把下划线看作第27个字母；

        2）常数：完全由数字组成的字符串；正数和0前面不加符号，负数在正数前面加-构成；长度不超过15；

        3）关键字、运算符、分隔符仅包含在文法定义中出现过的单词。

        4）字母表定义为 1.）∽ 3.）中出现的字符的集合；不在该集合中的符号都以非法字符对待；

晨曦✘
关注
编译原理实验：词法分析程序设计与实现/NFA确定化为DFA的算法实现
10-28
编译原理实验：词法分析程序设计与实现。对一个简单语言的子集编制一个一遍扫描的词法分析程序；构造一程序，实现：将给定的NFA M( 其状态转换矩阵及初态、终态信息保存在指定文件中)确定化为 DFA M，输出 DFA M 其...
22年山科大编译原理实验：词法分析之基于文法实现
07-13
个人手写代码，codeblock直接跑，报告...实现类C/C++语言单词识别程序 即可以处理c++语言源程序，过滤掉空格等无用符号，判断源程序中单词的合法性，并分解出正确的单词（以1~6代表），并以二元组形式存放在文件中。
编译原理 实验一 词法分析器设计源代码+实验报告
04-10
识别单词的词法分析程序，包括实验报告和源代码、流程图、表格和测试文件等。 编写程序实现： 1、输入：txt文件（存放要分析的源程序） 2、输出：从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、...
编译原理 - 词法分析：C/C++实现
11-15
通过这次实验，我深入了解了词法分析的过程和原理，并体会到了其在编译过程中的重要性和作用。在这个过程中，我遇到了一些困难，但也获得了宝贵的经验和收获。首先，词法分析是编译过程中的第一个阶段，负责将源代码...
编译原理实验1词法分析器
03-08
编译原理实验1词法分析器 本实验的目的是设计、编制并调试一个词法分析程序，以加深对词法分析原理的理解。实验的主要内容包括实验预习、实验报告、实验原理、扫描子程序算法思想、实验设备和实验要求等几个方面。 ...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 976
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 960
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 452
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 849
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 226
【代码】求n的阶乘的相反数（c语言）
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 645
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C#测试调用Ghostscript.NET浏览PDF文件
gc_2299的博客
09-23 414
学习并测试调用Ghostscript.NET模块打开及浏览PDF文件的基本用法
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 655
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
简易STL实现 | Set 的实现
AsherGu的博客
09-26 266
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 714
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
C++-Primer-Plus：18 个重点笔记
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 774
虽然从理论上讲，前缀递增/递减操作符由于不需要保存操作前的值而可能更高效，但这种差异在现代C++编程实践中往往被编译器的优化所掩盖。因此，在选择使用前缀还是后缀操作符时，更应该关注的是代码的清晰性和可读性，而不是微小的效率差异。在大多数情况下，遵循团队的编码规范或个人的编码习惯即可。最后，对于C++ Primer这样的经典书籍来说，它可能更多地是从语言规范和实现原理的角度来讨论这个问题，而不是从实际应用中的性能差异出发。
C++ 解析 RDP 协议
道亦无名
09-22 359
远程桌面协议（Remote Desktop Protocol, RDP）是微软开发的一种网络通信协议，用于提供远程桌面会话服务。它允许用户通过网络连接至远程计算机，并像使用本地计算机一样操作远程系统。本文档将详细探讨在C++环境中如何解析RDP协议，涵盖协议层次解析、连接过程管理、数据加密解密、功能数据处理、错误与异常处理以及协议版本适配等方面。
第一章：开始学习C语言-1介绍C语言
pingguocu3的博客
09-23 897
这篇文章将帮你了解C语言，它的历史，主要特点和应用。C语言是1970年发明的一种通用的过程式编程语言。C语言适用于操作系统、数据库系统、图形软件等系统编程。游戏引擎。最后编辑于：2024-09-22 09:32:39©著作权归作者所有,转载或内容合作请联系作者。
C++之模版的进阶
2301_81857941的博客
09-22 918
一个程序由若干个源文件共同实现，而每一个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。【优点】1.增强了代码的灵活性2.模版复用了代码，节省资源【缺陷】1.模版会导致代码膨胀问题2.出现模版错误时，错误原因难以定位。
广州大学编译原理实验：词法分析程序设计
"广州大学学生的编译原理实验报告，内容涉及词法分析器的设计与实现，包括实验目的、实验内容、实验原理、实验设备、实验要求以及实验程序。实验使用了C++编程语言，实现了一个简单的词法分析器，能够处理特定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值