广州大学编译原理-实验一词法分析器

已于 2024-01-25 12:31:59 修改
阅读量2k 收藏 49
点赞数 36
分类专栏： 编译原理 文章标签： c++
于 2024-01-24 22:11:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67573751/article/details/135832412
版权

广州大学学生实验报告

开课学院及实验室：计算机科学与工程实验室电子楼412B室          2023年12月19日

学院

计算机科学与网络工程学院

年级、专业、班

****

姓名

***

学号

****

实验课程名称

编译原理实验

成绩

      ***

实验项目名称

词法分析

指导老师

****

一、语法分析——实验目的

通过设计、扩充已有的 C 语言样例中的词法分析内容，为扩展的 C 语言样

例编制并调试一个词法分析程序，从而掌握词法分析程序的构造方法，加深对词

法分析原理的理解。

二、实验环境

（实验使用的软件/硬件环境）win11, dev C++, vs code, vs

三、实验内容及原理

基本实验要求

1) 编码实现将各类编程语言（不仅限指导书中提供的 C 语言样例）源程序

翻译成对应的二元组 TOKEN 序列，并能检查一定的词法错误，要求在

实现的代码上做好详细注释。

2) 编码实现的功能包含对关键字、带下划线的标识符、字符串常量、 注释

的识别，10 或 16 进制的整型常量、带指数的双精度常量的识别，以及

词法错误处理(选做)。

3) 按模板撰写完成详细的实验报告，根据完成的工作量、正确性和代码注

释与实验报告清晰程度综合打分。

探索部分实验要求

(一)依据表示标识符的正规式给出最简 DFA 的状态转换图

输入：表示标识符的正规式（标识符：以字母开头，由字母和数字构成的字符串）。

输出：

n 确定化后的 NFA 状态转换图或转换矩阵和初、终态；

n 最简化后的 DFA 状态转换图或状态转换矩阵及初、终态；

编码实现以下功能：

(1) 明确字母表∑中包含的字符，输入表示标识符的正规式，依据等价规则

构造相应的 NFA；(思考 NFA 的状态转换图以什么样的形式来存储)

(2) 编码实现对 NFA 的确定化，生成对应的 DFA；（难点）

(3) 编码实现对 DFA 的最简化，并输出其状态转换图。

(二)上传源程序代码图片，识别图中有效字符代码，并按照基础实验

要求完成对代码中不同类型单词的识别和输出

输入：包含源代码的图片（图片格式不限，但必须包含基础实验要求中待识别的

单词对象）。

输出：同基础实验要求一样

编码实现以下功能：

(1) 编码识别图中源程序的各项有效代码字符并进行存储，要求不改变代码

原意。

(2) 同基础实验要求一样。

完整代码

#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <set>
using namespace std;

// 单词的类型
enum TokenType
{

    Keywords,
    Identifiers,
    Literals,   // 常数
    Operators,  // 运算符
    Delimiters, // 界符
};

// 结构体 : 包含单词类型, 种别码, 值
struct Token
{
    TokenType tokenType; // 单词类型
    int syn;             // 种别码
    string value;        // 值

    // 构造函数
    Token(TokenType tokenType1, int syn1, string value1)
    {
        this->tokenType = tokenType1;
        this->syn = syn1;
        this->value = value1;
    }

    Token() {}
};

vector<Token> ans; // 二元组结果
vector<string> ans_error;
vector<string> keywords = {
    "main", "int", "char", "if", "else", "for", "while", "return", "void"}; // 保留字

// 种别码

map<string, int> getSyn = {
    {"main", 1},
    {"int", 2},
    {"char", 3},
    {"if", 4},
    {"else", 5},
    {"for", 6},
    {"while", 7},
    {"return", 8},
    {"void", 9},
    {"string", 50},
    {"id", 10},
    {"num", 20},
    {"=", 21},
    {"+", 22},
    {"-", 23},
    {"*", 24},
    {"“", 11},

    // 第二列
    {"/", 25},
    {"(", 26},
    {")", 27},
    {"[", 28},
    {"]", 29},
    {"{", 30},
    {"}", 31},
    {",", 32},
    {":", 33},
    {";", 34},
    {">", 35},
    {"<", 36},
    {">=", 37},
    {"<=", 38},
    {"==", 39},
    {"!=", 40},
    {"”", 12},
};

bool isKeyWord(string s)
{
    int n = keywords.size();
    for (int i = 0; i < n; i++)
    {
        if (s == keywords[i])
        {
            return true;
        }
    }
    return false;
}

void tokenize(string sourceCode)
{
    int n = sourceCode.size();
    for (int i = 0; i < n; i++)
    {

        char ch = sourceCode[i];

        // 字母 ： 保留字或者标识符
        // 字母开头或者_下划线开头
        if (isalpha(ch) || ch == '_')
        {
            string currentToken = ""; // 当前单词

            while (i < n && (isdigit(sourceCode[i]) || isalpha(sourceCode[i]) || sourceCode[i] == '_'))
            {
                currentToken += sourceCode[i];
                i++;
            }

            // 遇到了其他字符(空格， “”， 或者其他（）)
            // 查询是否是保留字
            if (isKeyWord(currentToken))
            {
                Token token;
                token.tokenType = Keywords;
                token.syn = getSyn[currentToken];
                token.value = currentToken;
                ans.push_back(token);
            }
            // 标识符
            else
            {
                Token token;
                token.tokenType = Identifiers;
                token.syn = getSyn["id"]; // id的种别码
                token.value = currentToken;
                ans.push_back(token);
            }
            i--;
        }

        // 数字
        // 添加功能 : 小数点
        else if (isdigit(ch))
        {
            string currentToken = "";
            int j;
            set<char> st; // 记录 小数点, e, E的出现次数;
            for (j = i; j < n; j++)
            {

                // 数字
                if (isdigit(sourceCode[j]))
                {
                    currentToken += sourceCode[j];
                }
                // 小数点
                else if (sourceCode[j] == '.')
                {
                    // 第一次出现小数点
                    if (!st.count('.'))
                    {
                        st.insert('.');
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 浮点数出现了两个小数点.");
                    }
                }
                // 字母e和字母E
                else if (sourceCode[j] == 'e' || sourceCode[j] == 'E')
                {
                    // 第一次出现e
                    if (!st.count(sourceCode[j]))
                    {
                        st.insert(sourceCode[j]);
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 科学记数法出现了两个e或者E.");
                    }
                }

                // e后面有+和-
                else if (sourceCode[j] == '+' || sourceCode[j] == '-')
                {
                    // 第一次出现这个
                    if (!st.count(sourceCode[j]) && (sourceCode[j - 1] == 'e' || sourceCode[j - 1] == 'E'))
                    {
                        st.insert(sourceCode[j]);
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 科学记数法中 : + 或者 -出现问题, (重复出现或者前面没有e或者E)");
                    }
                }

                else
                {
                    break;
                }
            }

            Token token;
            token.tokenType = Literals;
            token.syn = getSyn["num"];
            token.value = currentToken;
            ans.push_back(token);

            i = j - 1;
        }

        // 加号 +
        else if (ch == '+')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["+"];
            token.value = "+";
            ans.push_back(token);
        }

        // 减号
        else if (ch == '-')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["-"];
            token.value = "-";
            ans.push_back(token);
        }

        // 乘号
        else if (ch == '*')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["*"];
            token.value = "*";
            ans.push_back(token);
        }

        // 小于 或者 小于等于
        if (ch == '<')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = "<=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["<="];
                token.value = "<=";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = "<";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["<"];
                token.value = "<";
                ans.push_back(token);
            }
        }

        // 大于 或者 大于等于
        if (ch == '>')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = ">=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn[">="];
                token.value = ">=";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = ">";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn[">"];
                token.value = ">";
                ans.push_back(token);
            }
        }

        //= 或者 ==
        if (ch == '=')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = "==";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["=="];
                token.value = "==";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = "=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["="];
                token.value = "=";
                ans.push_back(token);
            }
        }

        // 分号
        if (ch == ';')
        {
            Token token;
            token.tokenType = Delimiters;
            token.syn = getSyn[";"];
            // token.value = "" + ch; //不能直接拼接
            token.value = ";";

            ans.push_back(token);
        }

        // 字符串常量 : 双引号
        else if (ch == '"')
        {
            Token tokenLeft(Delimiters, getSyn["\""], "\"");
            ans.push_back(tokenLeft); // 双引号

            bool contain = false;
            int j = i + 1;
            for (j = i + 1; j < n; j++)
            {
                if (sourceCode[j] == '"')
                {
                    contain = true;
                    break;
                }
            }

            //""不成对出现
            if (contain == false)
            {
                string s = "编译错误, 双引号\"\"缺失, 没有成对出现";
                ans_error.push_back(s);
            }
            else
            {
                string currentToken = sourceCode.substr(i + 1, (j - 1) - (i + 1) + 1);
                Token token;
                token.tokenType = Literals;
                token.syn = getSyn["string"];
                token.value = currentToken;

                ans.push_back(token);
                Token tokenRight(Delimiters, getSyn["\""], "\""); // 双引号
                ans.push_back(tokenRight);                        // 双引号

                i = j;
            }
        }

        // ()
        else if (ch == '(' || ch == ')')
        {

            if (ch == '(')
            {
                Token tokenLeft(Delimiters, getSyn["("], "(");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == ')')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 括号)缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn[")"], ")");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // []
        else if (ch == '[' || ch == ']')
        {

            if (ch == '[')
            {
                Token tokenLeft(Delimiters, getSyn["["], "[");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == ']')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 中括号 ] 缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn["]"], "]");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // {}
        else if (ch == '{' || ch == '}')
        {

            if (ch == '{')
            {
                Token tokenLeft(Delimiters, getSyn["{"], "{");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == '}')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 大括号 } 缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn["}"], "}");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // 冒号
        else if (ch == ':')
        {
            Token token;
            token.tokenType = Delimiters;
            token.syn = getSyn[":"];
            token.value = ":";

            ans.push_back(token);
        }

        // 叹号
        else if (ch == '!')
        {
            if (sourceCode[i + 1] == '=')
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["!="];
                token.value = "!=";
                ans.push_back(token);
                i++;
            }

            else
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["!"];
                token.value = "!";
                ans.push_back(token);
            }
        }

        // 点 .
        else if (ch == '.')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["."];
            token.value = ".";
            ans.push_back(token);
        }

        // 除号/ 注释
        else if (ch == '/')
        {
            // 注释1 : //
            if (sourceCode[i + 1] == '/')
            {
                int j = i + 2;
                string s = "//";
                while (j < n && sourceCode[j] != '\n')
                {
                    s += sourceCode[j];
                    j++;
                }

                i = j;
                Token token;
                token.tokenType = Literals;
                token.value = s;
                ans.push_back(token);
            }
            // 注释2 : / *  * /
            else if (sourceCode[i + 1] == '*')
            {
                int j = i + 2;
                while (j + 1 < n && !(sourceCode[j] == '*' && sourceCode[j + 1] == '/'))
                {
                    j++;
                }

                // /* 成对出现  : 正常
                if (sourceCode[j] == '*' && sourceCode[j + 1] == '/')
                {
                    string s = "/*" + sourceCode.substr(i + 2, j - 1 - (i + 2) + 1) + "*/";
                    Token token;
                    token.tokenType = Literals;
                    token.value = s;
                    ans.push_back(token);
                    i = j + 1;
                }
                else
                {
                    ans_error.push_back("编译错误, /* 注释符号不成对出现");
                }
            }
            // 普通除号
            else
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["/"];
                token.value = "/";

                ans.push_back(token);
            }
        }
    }
}
int main()
{

    // 打开文件
    cout << "正在打开文件... ..." << endl;
    fstream file("source_code.c");
    // fstream file("imgToCode.c");
    string sourceCode = "";
    if (!file.is_open())
    {
        cout << "打开文件失败" << endl;
    }
    else
    {
        cout << "打开文件成功" << endl;

        string buf;
        while (getline(file, buf))
        {
            buf = "\n" + buf;
            sourceCode += buf;
        }
    }

    // 读取文件的内容
    cout << "源程序的代码是 : " << endl;
    cout << sourceCode << endl;

    // 编译中
    tokenize(sourceCode);

    if (ans_error.size() == 0)
    {
        cout << "编译成功" << endl;
        for (auto token : ans)
        {
            cout << "( " << token.syn << " : " << token.value << " )" << endl;
        }
    }
    else {
        cout << "编译失败" << endl;
        for(auto s : ans_error) 
        cout << s << endl;
    }
}

四、关键数据结构和核心算法

4.1 数据结构

单词的类型 : 枚举类

结构体 : 包含单词类型, 种别码, 值


// 单词的类型
enum TokenType
{

    Keywords,
    Identifiers,
    Literals,   // 常数
    Operators,  // 运算符
    Delimiters, // 界符
};

// 结构体 : 包含单词类型, 种别码, 值
struct Token
{
    TokenType tokenType; // 单词类型
    int syn;             // 种别码
    string value;        // 值

    // 构造函数
    Token(TokenType tokenType1, int syn1, string value1)
    {
        this->tokenType = tokenType1;
        this->syn = syn1;
        this->value = value1;
    }

    Token() {}
};

  1. 2 核心算法


void tokenize(string sourceCode)
{
    int n = sourceCode.size();
    for (int i = 0; i < n; i++)
    {

        char ch = sourceCode[i];

        // 字母 ： 保留字或者标识符
        // 字母开头或者_下划线开头
        if (isalpha(ch) || ch == '_')
        {
            string currentToken = ""; // 当前单词

            while (i < n && (isdigit(sourceCode[i]) || isalpha(sourceCode[i]) || sourceCode[i] == '_'))
            {
                currentToken += sourceCode[i];
                i++;
            }

            // 遇到了其他字符(空格， “”， 或者其他（）)
            // 查询是否是保留字
            if (isKeyWord(currentToken))
            {
                Token token;
                token.tokenType = Keywords;
                token.syn = getSyn[currentToken];
                token.value = currentToken;
                ans.push_back(token);
            }
            // 标识符
            else
            {
                Token token;
                token.tokenType = Identifiers;
                token.syn = getSyn["id"]; // id的种别码
                token.value = currentToken;
                ans.push_back(token);
            }
            i--;
        }

        // 数字
        // 添加功能 : 小数点
        else if (isdigit(ch))
        {
            string currentToken = "";
            int j;
            set<char> st; // 记录 小数点, e, E的出现次数;
            for (j = i; j < n; j++)
            {

                // 数字
                if (isdigit(sourceCode[j]))
                {
                    currentToken += sourceCode[j];
                }
                // 小数点
                else if (sourceCode[j] == '.')
                {
                    // 第一次出现小数点
                    if (!st.count('.'))
                    {
                        st.insert('.');
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 浮点数出现了两个小数点.");
                    }
                }
                // 字母e和字母E
                else if (sourceCode[j] == 'e' || sourceCode[j] == 'E')
                {
                    // 第一次出现e
                    if (!st.count(sourceCode[j]))
                    {
                        st.insert(sourceCode[j]);
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 科学记数法出现了两个e或者E.");
                    }
                }

                // e后面有+和-
                else if (sourceCode[j] == '+' || sourceCode[j] == '-')
                {
                    // 第一次出现这个
                    if (!st.count(sourceCode[j]) && (sourceCode[j - 1] == 'e' || sourceCode[j - 1] == 'E'))
                    {
                        st.insert(sourceCode[j]);
                        currentToken += sourceCode[j];
                    }
                    else
                    {
                        ans_error.push_back("错误, 科学记数法中 : + 或者 -出现问题, (重复出现或者前面没有e或者E)");
                    }
                }

                else
                {
                    break;
                }
            }

            Token token;
            token.tokenType = Literals;
            token.syn = getSyn["num"];
            token.value = currentToken;
            ans.push_back(token);

            i = j - 1;
        }

        // 加号 +
        else if (ch == '+')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["+"];
            token.value = "+";
            ans.push_back(token);
        }

        // 减号
        else if (ch == '-')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["-"];
            token.value = "-";
            ans.push_back(token);
        }

        // 乘号
        else if (ch == '*')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["*"];
            token.value = "*";
            ans.push_back(token);
        }

        // 小于 或者 小于等于
        if (ch == '<')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = "<=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["<="];
                token.value = "<=";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = "<";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["<"];
                token.value = "<";
                ans.push_back(token);
            }
        }

        // 大于 或者 大于等于
        if (ch == '>')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = ">=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn[">="];
                token.value = ">=";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = ">";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn[">"];
                token.value = ">";
                ans.push_back(token);
            }
        }

        //= 或者 ==
        if (ch == '=')
        {
            if (sourceCode[i + 1] == '=')
            {
                string currentToken = "==";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["=="];
                token.value = "==";
                ans.push_back(token);
                i++;
            }
            else
            {
                string currentToken = "=";
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["="];
                token.value = "=";
                ans.push_back(token);
            }
        }

        // 分号
        if (ch == ';')
        {
            Token token;
            token.tokenType = Delimiters;
            token.syn = getSyn[";"];
            // token.value = "" + ch; //不能直接拼接
            token.value = ";";

            ans.push_back(token);
        }

        // 字符串常量 : 双引号
        else if (ch == '"')
        {
            Token tokenLeft(Delimiters, getSyn["\""], "\"");
            ans.push_back(tokenLeft); // 双引号

            bool contain = false;
            int j = i + 1;
            for (j = i + 1; j < n; j++)
            {
                if (sourceCode[j] == '"')
                {
                    contain = true;
                    break;
                }
            }

            //""不成对出现
            if (contain == false)
            {
                string s = "编译错误, 双引号\"\"缺失, 没有成对出现";
                ans_error.push_back(s);
            }
            else
            {
                string currentToken = sourceCode.substr(i + 1, (j - 1) - (i + 1) + 1);
                Token token;
                token.tokenType = Literals;
                token.syn = getSyn["string"];
                token.value = currentToken;

                ans.push_back(token);
                Token tokenRight(Delimiters, getSyn["\""], "\""); // 双引号
                ans.push_back(tokenRight);                        // 双引号

                i = j;
            }
        }

        // ()
        else if (ch == '(' || ch == ')')
        {

            if (ch == '(')
            {
                Token tokenLeft(Delimiters, getSyn["("], "(");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == ')')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 括号)缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn[")"], ")");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // []
        else if (ch == '[' || ch == ']')
        {

            if (ch == '[')
            {
                Token tokenLeft(Delimiters, getSyn["["], "[");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == ']')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 中括号 ] 缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn["]"], "]");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // {}
        else if (ch == '{' || ch == '}')
        {

            if (ch == '{')
            {
                Token tokenLeft(Delimiters, getSyn["{"], "{");
                ans.push_back(tokenLeft); // 双引号
                bool contain = false;
                int j = i + 1;
                for (j = i + 1; j < n; j++)
                {
                    if (sourceCode[j] == '}')
                    {
                        contain = true;
                        break;
                    }
                }
                //""不成对出现
                if (contain == false)
                {
                    string s = "编译错误, 大括号 } 缺失, 没有成对出现";
                    ans_error.push_back(s);
                }
            }

            // 右括号
            else
            {
                Token tokenLeft(Delimiters, getSyn["}"], "}");
                ans.push_back(tokenLeft); // 双引号
            }
        }

        // 冒号
        else if (ch == ':')
        {
            Token token;
            token.tokenType = Delimiters;
            token.syn = getSyn[":"];
            token.value = ":";

            ans.push_back(token);
        }

        // 叹号
        else if (ch == '!')
        {
            if (sourceCode[i + 1] == '=')
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["!="];
                token.value = "!=";
                ans.push_back(token);
                i++;
            }

            else
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["!"];
                token.value = "!";
                ans.push_back(token);
            }
        }

        // 点 .
        else if (ch == '.')
        {
            Token token;
            token.tokenType = Operators;
            token.syn = getSyn["."];
            token.value = ".";
            ans.push_back(token);
        }

        // 除号/ 注释
        else if (ch == '/')
        {
            // 注释1 : //
            if (sourceCode[i + 1] == '/')
            {
                int j = i + 2;
                string s = "//";
                while (j < n && sourceCode[j] != '\n')
                {
                    s += sourceCode[j];
                    j++;
                }

                i = j;
                Token token;
                token.tokenType = Literals;
                token.value = s;
                ans.push_back(token);
            }
            // 注释2 : / *  * /
            else if (sourceCode[i + 1] == '*')
            {
                int j = i + 2;
                while (j + 1 < n && !(sourceCode[j] == '*' && sourceCode[j + 1] == '/'))
                {
                    j++;
                }

                // /* 成对出现  : 正常
                if (sourceCode[j] == '*' && sourceCode[j + 1] == '/')
                {
                    string s = "/*" + sourceCode.substr(i + 2, j - 1 - (i + 2) + 1) + "*/";
                    Token token;
                    token.tokenType = Literals;
                    token.value = s;
                    ans.push_back(token);
                    i = j + 1;
                }
                else
                {
                    ans_error.push_back("编译错误, /* 注释符号不成对出现");
                }
            }
            // 普通除号
            else
            {
                Token token;
                token.tokenType = Operators;
                token.syn = getSyn["/"];
                token.value = "/";

                ans.push_back(token);
            }
        }
    }
}

python图像识别 :

import pytesseract
from PIL import Image
# 识别图片
image = Image.open('img.png')
code = pytesseract.image_to_string(image, lang='eng')

print(code)
# 将识别出来的代码写入文件
file = open("E:\code\Complilers\\test1\imgToCode.c", "w")
file.write(code)

4.3 错误处理

4.4 运行结果

五、总结

实现了一个词法分析器

  1. 对输入源程序字符串进行词法分析,输出二元组序列,包括对以下字符的分析
    1. 关键字
    2. 带下划线的标识符
    3. 字符串常量
    4. 注释
    5. 科学计数法
  2. 实现OCR图像, 能够对图像形式的c程序代码, 进行识别得到源程序字符串, 并对其进行分析.

Eren Yeager1
关注
  • 36
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
编译原理实验报告
⊙-→棒棒糖ing .____`
11-23 1万+
20160119提交的编译原理实验报告，一共有三次提交。程序其实不完美。 最近分析RFC等系列文档需要涉及词法、语法、语义。于是整合一下，回顾一下。
编译原理-实验
lzlyxxn的博客
06-26 5365
〖1.实验目的〗加深对词法分析器的工作过程的理解;加强对词法分析方法的掌握;能够采用一种编程语言实现简单的词法分析程序;能够使用自己编写的分析程序对简单的程序段进行词法分析。〖2.实验内容〗 类C语言的手工词法分析器设计〖3.实验要求〗（1）C语言子集（最好能对实际的C源代码进行词法分析，从而省去样例设计）（2）一符一种（3）单字符单词（算符、界符）的种码等于其ASCII码，不必设计； 关键字和双字符运算符，种码...
编译原理之LL(1)语法分析实验（附完整C/C++代码与测试）
轻舟终过万重山
05-24 1万+
编译原理实验之LL（1）语法分析实验,使用C语言实现，附带详细注释并测试结果
编译原理实验一 《词法分析程序设计与实现》
Atlas
05-03 1万+
编译原理实验一 《词法分析程序设计与实现》 一、实验目的 ​加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。 二、实验内容 自定义一种程序设计语言，或者选择已有的一种高级语言，编制它的词法分析程序。词法分析程序的实现可以采用任何一种编程语言和编程工具。从输入的源程序中，识别出各个具有独立意义的单词，即关键字、标识符、常数、运算符、界符。并依次输出各个单词的内部编码及单词符号自身值。（遇到错误时可显示
编译原理实验一
qq_43527659的博客
12-29 4417
一、 实验目的 通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 这里以开始定义的c语言子集的源程序作为词法分析程序的输入数据。在词法分析中，自文件头开始扫描源程序字符，一旦发现符合“单词”定义的源程序字符串时，将它翻译成固定长度的单词内部表示，并查填适当的信息表。经过词法分析后，源程序字符串（源程序的外部表示）被翻译成具有等长信息的单词串（源程序的内部表示），并产生两个表格：常数表和标识符表，它们分别包含了源程序
编译原理之词法分析实验（附完整C/C++代码与总结）
轻舟终过万重山
05-23 7176
编译原理之词法分析实验，附完整详细代码与测试结果，最后有整体代码思路总结
编译原理实验1词法分析器
03-08
编译原理实验1词法分析器 本实验的目的是设计、编制并调试一个词法分析程序，以加深对词法分析原理的理解。实验的主要内容包括实验预习、实验报告、实验原理、扫描子程序算法思想、实验设备和实验要求等几个方面。 ...
广州大学编译原理全实验报告
01-23
在这个实验中，学生可能会学习如何创建一个词法分析器，识别并分类程序中的关键字、标识符、运算符、常量和字符串等元素。例如，他们可能需要编写正则表达式来匹配不同类型的标记，并实现一个有限状态自动机（FSA）...
编译原理实验词法分析语法分析
11-26
这份资料将帮助学习者深入理解词法分析器和语法分析器的设计与实现，通过实际操作加深对编译原理的理解。 总的来说，这个实验旨在让学习者掌握编译器的基本构造块，并运用到实际项目中。通过词法分析器的构建，学生...
广州大学编译原理实验报告.rar
01-29
这份"广州大学编译原理实验报告"包含了实验一、实验二和实验三的详细内容，是学习和理解编译器工作原理的宝贵资料。 实验一是编译器基础构建模块的学习，通常会涉及词法分析和语法分析。词法分析，又称扫描，是将源...
广州大学编译原理试卷及答案及复习重点.7z
03-27
内涵19年复习重点及往年试卷 选择题 2*10=20 填空题 1*20=20 简答题 10*2=20 综合题 40 ☆中间语言 ☆first、follow、FirstVt、LastVt ☆LL(1)分析表构造 ☆算符优先关系表构造 ☆SLR(1)分析构造 第一章 ●所有基本概念 编译程序基本概念；编译与汇编程序的概念与关联；翻译、编译与解释程序的概念与关联；源程序与目标程序的概念与关联；编译过程与编译程序一般结构；遍的概念；自编译、交叉编译、自展和移植 第二章 ●词法分析的输入与输出，词法分析的组织方式，扫描器 ●什么是“单词”，编译程序的单词可以怎么分类与输出保存？ ●语言的正规表达式 正规式描述能力（例2.1，例2.2，例2.3，习题2.4） 使用正规式描述特定的内容（习题2.5，习题2.6） ●有限自动机，状态转换图，状态转换矩阵 例2.4， 2.5的DFA/NFA的状态图/状态矩阵绘制 ●正规式->NFA非确定有限自动机 例2.6 ●NFA确定化 ε_CLOSURE（等价状态集），Ia（状态集经过a出边抵达的等价状态集），子集法（例2.8），DFA化简（分为终态与非终态进行考察划分，例2.9）
广州大学编译原理课程PPT与复习资料.zip
01-27
2. **词法分析**：编译器首先将源代码分解成一个个称为“token”的基本单元，词法分析器负责识别这些token并将其分类。 3. **语法分析**：语法分析器根据语法规则解析token序列，构建抽象语法树（AST），这是理解...
编译原理四大实验——Java
m0_58233492的博客
05-30 1404
自己慢慢摸索写出的集词法分析、递归下降分析、LL1、波兰式于一体的且带有UI界面的程序。 以下是四个实验目的阐述与结果截图，会贴上最重要的代码。 由于代码有些大，会附有链接收取一点点积分换取完整代码。
编译原理实验四
12-15 2053
HNU编译原理实验四
编译原理-实验四-LR(0)语法分析程序的设计
热门推荐
wys5的博客
12-20 3万+
一、实验目的 了解LR(0)语法分析算法的基本思想，掌握LR(0)语法分析程序的构造方法。 二、实验内容 根据LR(0)语法分析算法的基本思想，设计一个对给定文法进行LR(0)语法分析的程序，并用C、C++或Java语言编程实现。要求程序能够对从键盘输入的任意字符串进行分析处理，判断出该输入串是否是给定文法的有效句子，并针对该串给出具体的LR(0)语法分析过程。 三、实验要求 1、已知文...
编译原理 实验2 词法分析（C/C++版）
qq_56893454的博客
05-19 1159
使用C/C++语言编写PL/0编译程序的词法分析程序。需要注意的点： （1）识别非法字符：如 @ 、 & 和!（2）识别非法单词：数字开头的数字字母组合；（3）标识符和无符号整数的长度不超过8位；（4）能自动识别并忽略/* */及//格式的注释信息；（5）词法分析过程中遇到错误后能继续往下识别，并输出错误信息。完成上述编程任务，将C/C++语言源程序复制粘贴到右侧代码编辑器，点击“评测”按钮，运行程序，系统会自动进行结果对比。
编译原理实验-词法分析
001
05-26 3186
用flex生成一个词法分析器，用以识别SysY语法，具体的以test_cases中的文件作为输入，输出token二元组，识别程序中所有的常数、运算符、界符、标识符及关键字。总的来说，通过本次词法分析器实现的实验，对Flex这一词法分析器生成工具的功能有了一个整体的认识，同时也对编译过程中的词法分析过程有了一个更加全面的认知。如下图1-1(a),1-1(b)所示。(1) 分别输入整数123，-123以及浮点数12.5，-12.5，测试该词法分析器对整数与浮点数的分析效果，结果如图2-1所示。
编译原理实验1：词法分析设计
u25th_engineer的博客
10-09 4765
通过本实验的编程实践,使学生了解词法分析的任务,掌握词法分析程序设计的原理和构造方法,使学生对编译的基本概念、原理和方法有完整的和清楚的理解,并能正确地、熟练地运用。 用 VC++/VB/JAVA 语言实现对 C 语言子集的源程序进行词法分析。通过输入源程序从左到右对字符串进行扫描和分解,依次输出各个单词的内部编码及单词符号自身值;若遇到错误则显示“Error”,然后跳过错误部分继续显示 ;同时进行标识符登记符号表的管理。
编译原理--基础词法分析实验
最新发布
04-12
基础词法分析实验是编译原理中的一部分，它主要涉及词法分析器的设计与实现。 词法分析器是编译器的第一个阶段，它负责将源代码分解成一个个的词法单元（token），并生成对应的词法单元流。词法单元是编程语言中的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值