编译原理--C-Minus词法分析器C++实现

最新推荐文章于 2024-05-25 10:36:02 发布
最新推荐文章于 2024-05-25 10:36:02 发布
阅读量1.4w 收藏 50
点赞数 5
分类专栏： 学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hiluo302/article/details/51242313
版权

词法分析器的主要功能是把源代码整理成一个个记号（token），记号的类型主要有系统保留字（if，return等）、特殊字符（+，*，/等）、字符串记号（数字和标志符）。
如：str[i] = 45 + 6;
将上面代码整理：
标识符：str，i
特殊符：[ , ],+
数字 ： 45，6

DFA如下：
这里写图片描述

c-测试源代码：

/* A program to perform Euclid's
Algorithm to compute gcd. */

int gcd (int u, int v)
{
    if (v == 0)
        return u ;
    else
        return gcd(v,u-u/v*v);
    /* u-u/v*v == u mod v */
}

void main(void)
{
    int x; int y;
    x = input();
    y = input();
    output(gcd(x,y));
}

代码实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<iostream>
#define sfName "source.c"
#define tfName "target.c"
typedef int sInt;
using namespace std;

FILE *source;
FILE *target;

long beginp[5];   //记录文件指针的开始位置
long endp[5];    //记录文件指针的结束位置
char idStr[80]="";   //保存标识符中间值
int state[5]={0}; //不同记号类型的状态
char unaryOP[16]={'+','-','*','/','<','>','=',';',',','(',')','[',']','{','}','!'}; //保存一元运算符
char *p[6]={"if","else","int","return","void","while"};  //系统保留字
char *strToken[7]={"ID","NUM","OP","FUCN","RESW","ERROR","COM"};
typedef enum {ID,NUM,OP,FUCN,RESW,ERROR,COM}tokenType; //记号类型

void clearState()
{
    memset(state,0,sizeof(state));
    memset(idStr,'\0',sizeof(idStr));
    memset(beginp,0,sizeof(beginp));
    memset(endp,0,sizeof(endp));
}

void strPrintf(long begin,long end,tokenType t)
{
    bool isComment = false;
    int k;
    char s[200]="";
    long len=end-begin;
    //printf("%d %d\n",begin,end);
    fseek(source,-len,1);//文件指针回退
    for(int i=0;i<len;i++)
    {
        s[i]=fgetc(source);
    }
    //fseek(source,len,1); //文件指针归位
    switch(t)
    {
        case ID:
        k=0;break;
        case NUM:
        k=1;break;
        case OP:
        k=2;break;
        case FUCN:
        k=3;break;
        case RESW:
        k=4;break;
        case ERROR:
        k=5;break;
        case COM:
        k=6;
        isComment=true;break;
        default:cout<<"输入有误！\n";
    }
    //printf("%s\n",s);
    if(isComment)
    {
        fprintf(target,"%s\n",s);
        printf("%s\n",s);
    }

    else
    {
        fprintf(target,"<%s,%s>\n",strToken[k],s);
        printf("<%s,%s>\n",strToken[k],s);
    }
}

void unaryPrintf(char s,tokenType t)
{
    int k;
    switch(t)
    {
        case ID:
        k=0;break;
        case NUM:
        k=1;break;
        case OP:
        k=2;break;
        case FUCN:
        k=3;break;
        case RESW:
        k=4;break;
        case ERROR:
        k=5;break;
        case COM:
        k=6;break;
        default:cout<<"输入有误！\n";
    }
    //cout<<strToken[k]<<endl;
    fprintf(target,"<%s,%c>\n",strToken[k],s);
    printf("<%s,%c>\n",strToken[k],s);
}

bool isOperator(char ch)
{
    for(int i=0;i<16;i++)
    {
        if( ch==unaryOP[i] )
        return true;
    }
    return false;
}

void comment(char ch,int i)
{
    bool isexit = false; //当不是注释时用于跳出循环
    //tokenType t=COM;
    while(!feof(source))
    {
        switch(state[i])
        {
            case 0:
            if(ch=='/')
            {
                state[i]=1;
                beginp[i]=ftell(source)-1;
            }
            break;
            case 1:
            if(ch=='*')
            {
                state[i]=2;
            }
            else
            {
                isexit = true; //说明不是注释，请求退出
                unaryPrintf('/',OP);
                fseek(source,-1L,1); //回退一个字节，因为向后判断移了一位
            }
            break;
            case 2:
            if(ch=='*')
            {
                state[i]=3;
            }else
            {
                state[i]=2;
            }
            break;
            case 3:
            if(ch=='/')
            {
                state[i]=4;
                endp[i]= ftell(source);
                strPrintf( beginp[i],endp[i],COM);
                isexit = true;                               //back
            }else state[i]=2;
            break;
        }
        if(isexit) return;//back;
        ch = fgetc(source);
    }
}

void number(char ch,int i)
{
    beginp[i]=ftell(source)-1;
    while(!feof(source))
    {
        if(ch>='0' && ch<='9')
        {
            state[i]=1;
            endp[i]=ftell(source);
        }else
        {
            fseek(source,-1L,1); //回退,读到了下一个字符
            strPrintf(beginp[i],endp[i],NUM);
            return;
        }
        ch = fgetc(source);
    }
}

void myOperator(char ch,int i)
{
    bool isReturn = false;
    while(!feof(source))
    {
        if(ch=='+' ||ch=='-'||ch=='*'||ch==';'||ch==','||ch=='('||ch==')'||ch=='['||ch==']'||ch=='{'||ch=='}')
        {
            state[i]=1;
            unaryPrintf(ch,OP);
            isReturn = true;
        }else
        {
            switch(state[i])
            {
                case 0:
                beginp[i]=ftell(source)-1;
                switch(ch)
                {
                    case '<':
                    state[i]=2;
                    break;
                    case '>':
                    state[i]=4;
                    break;
                    case '=':
                    state[i]=6;
                    break;
                    case '!':
                    state[i]=8;
                    break;
                    default:cout<<"data error!\n";
                }
                break;
                case 2:
                if(ch=='=')
                {
                    state[i]=3;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //属于一元操作符
                    state[i]=2;
                    fseek(source,-1L,1);//回退一个字符
                    unaryPrintf('<',OP);
                    isReturn = true;
                }
                break;
                case 4:
                if(ch=='=')
                {
                    state[i]=5;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //属于一元操作符
                    state[i]=4;
                    fseek(source,-1L,1);//回退一个字符
                    unaryPrintf('>',OP);
                    isReturn = true;
                }
                break;
                case 6:
                if(ch=='=')
                {
                    state[i]=7;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //属于一元操作符
                    state[i]=6;
                    fseek(source,-1L,1);//回退一个字符
                    unaryPrintf('=',OP);
                    isReturn = true;
                }
                break;
                case 8:
                if(ch=='=')
                {
                    state[i]=9;
                    endp[i]=ftell(source);
                    strPrintf(beginp[i],endp[i],OP);
                    isReturn = true;
                }else
                {
                    //属于一元操作符
                    state[i]=8;
                    fseek(source,-1L,1);//回退一个字符
                    unaryPrintf('!',OP);
                    isReturn = true;
                }
                break;
                default:cout<<"data error!\n";
            }
        }
        if(isReturn) return;
        ch = fgetc(source);
    }
}
bool isLiter(char ch)
{
    if((ch>='A' && ch<='Z')||( ch>= 'a' && ch<='z') || ch=='_')
    {
        return true;
    }else
    return false;
}

bool isResw(char *s)
{
    for(int i=0;i<6;i++)
    {
        if( strcmp(s,p[i])==0 )
        return true;
    }
    return false;
}

void identifier(char ch,int i)
{
    beginp[i] = ftell(source)-1;
    long len =0;
    bool isQuit = false;
    bool isFucn = false;
    while(!feof(source))
    {
        if( isLiter(ch) )
        {
            state[i]=1;
            endp[i]=ftell(source);
        }
        else
        {
            long enter = 1; //
            isQuit = true;
            if(ch=='\n') enter = 2;
            fseek(source,-enter,1); //回退一或2个字符
            //cout<<"pos="<<ftell(source)<<endl;
            //printf("%d %d\n",beginp[i],endp[i]);
            len = endp[i]-beginp[i];
            fseek(source,-len,1);
            //cout<<"pos="<<ftell(source)<<endl;
            for(int j=0;j<len;j++)
            {
                idStr[j] = fgetc(source);

            }
            if( isResw(idStr) ) //如果是保留字，就保存退出
            {
                strPrintf(beginp[i],endp[i],RESW);

            }else
            {
                char temps;
                long cout=1;
                temps = fgetc(source);
                while(!feof(source))
                {
                    if(temps==' ' ||temps=='\n' || temps=='\t')
                    {
                        ; //jump it;
                    }else
                    {
                        if(temps=='(')
                           {
                               isFucn = true; //表明是函数名
                               break;
                           }
                        else
                           {
                               isFucn = false; //不是函数名
                               break;
                           }
                    }
                    temps = fgetc(source);
                    cout++;
                }
                fseek(source,-cout,1); //回退文件指针
                //printf("back=%ld\n",ftell(source));
                if(isFucn)
                {
                    strPrintf(beginp[i],endp[i],FUCN);
                }else
                {
                    strPrintf(beginp[i],endp[i],ID);
                }
            }
        }
        if(isQuit) return;
        ch = fgetc(source);
    }
}

void startScanner()
{
    char ch=fgetc(source);
    while( !feof(source) )
    {
        if(ch==' ' ||ch=='\n' || ch=='\t')
        {
            ;//nothing jump it!
        }else if(ch=='/')
        {
            comment(ch,0);
            clearState(); //清楚状态信息
        }else if(ch>='0'&&ch<='9')
        {
            number(ch,1); //处理数字
            clearState();
        }else if( isOperator(ch) )
        {
            myOperator(ch,2); //处理操作符
            clearState();
        }else if( isLiter(ch) )
        {
            identifier(ch,3); //处理标志符
            clearState();
        }
        else
        {
            unaryPrintf(ch,ERROR);
        }
        ch = fgetc(source);
    }
}

int main()
{
    if((source=fopen(sfName,"r"))==NULL)
    {
        printf("文件打开失败！\n");
        exit(0);
    }
    if((target=fopen(tfName,"w"))==NULL)
    {
        fprintf(stderr,"文件写入失败！\n");
        exit(0);
    }
    startScanner();//开始扫描文件 entrance
    fclose(source);
    fclose(target);
    return 0;
}

实现小结：其实写词法分析器的DFA并不难，使用ifelse嵌套或者switch选择嵌套都可以，我觉得容易出现问题是对文本的读取，以上代码基本使用的是c的文件库函数实现。
需要注意的是：计算机从ASCII文件（文本文件）读入字符时，遇到回车换行符（两个字符‘\r,‘\n’)时，系统把它转化为一个字符’\n’。所以用户只能收到’\n’,不能收到’\r’。但是使用函数fseek（）时要格外小心。
看如下代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define fname "target.c"
#define filename "hiluo.txt"
using namespace std;

FILE *fp;
void solution()
{

    char ch;
    long pos;
    if((fp=fopen(filename,"r"))==NULL)
    {
        printf("open file error\n");
        exit(0);
    }
    ch = fgetc(fp); //接受第一个字符
    while(!feof(fp))
    {
        printf("%c",ch); //打印文本文件
        ch=fgetc(fp);
    }
    printf("\n");
    printf("\n");
    rewind(fp);//将文件指针指向文件头
    printf("文件的起始位置 = %ld\n",ftell(fp));
    ch =fgetc(fp);
    while(ch!='\n')
    {
        printf("%c",ch);  //输出换行符之前的字符
        ch = fgetc(fp);
    }
    putchar(10);
    pos = ftell(fp); //文件指针当前位置
    ch = fgetc(fp);
    printf("position = %ld\n",pos);
    printf("当前字符 = '%c'\n",ch);
    fclose(fp);
    putchar(10);
}

int main()
{
    solution();
    //cout << "Hello world!" << endl;
    return 0;
}

这里写图片描述

可以看到 ‘h’属于第五个字符，从0开始的h看似应该是第4个字符啊！
原来ftell()函数 并没有把’\r’忽略掉！这样编程就会遇到问题。
如文件指针回退 ，假如当前字符为’e’,回退到’c’,应该是fseek（fp，-4L，1）而不是fseek（fp，-3L，1）。这个问题让我找了两个小时的错误！
都到了崩溃的边缘了。~.~!

《完》

hiluo302
关注
  • 5
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++写的c minus词法分析器
07-08
《C++实现的C-Minus词法分析器详解》 在计算机科学中，编译器是将源代码转换为目标代码的关键工具，而词法分析器（也称为扫描器或词法分析程序）则是编译器的第一步，它将源代码分解成一个个有意义的单元——记号...
四川大学编译原理课程设计报告C-词法分析与语法分析
04-16
- **DNF分析**：词法分析器采用了确定有限自动机(DFA)的方法来识别不同类型的token。通过定义不同状态（如START、INNUM、INID等）来区分不同的token类型，并最终确定token的有效性。 ##### 2.4 语法分析 语法分析...
【编译原理】词法分析（C/C++源代码+实验报告）
热门推荐
xtcc的博客
10-13 8万+
文章目录1 实验目的和内容1.1实验目的1.2实验内容2 设计思想2.1单词种类及其正规式2.2 根据正规式构造NFA2.3根据NFA构造DFA2.3.1根据替换规则构造未化简的DFA2.3.2最小化DFA3算法流程4源程序5调试数据5.1 测试样例一5.2 测试样例二5.3 测试样例三6实验调试情况及体会6.1 实验调试情况6.2 实验体会 1 实验目的和内容 1.1实验目的 （1）根据 PL/0 语言的文法规范，编写PL/0语言的词法分析程序；或者调研词法分析程序的自动生成工具LEX或FLEX，设计并实
C++ (part1—C语言项目)：词法分析器
Edward2022的博客
05-15 333
C语言项目：词法分析器
编译原理实验：使用C/C++语言编写C-语言的词法分析器
程序分析爱好者
08-05 1万+
文章目录实验目的实验任务实验内容实验步骤分析c-的词法规则算法基本思想Step1 find token：Step2：DFA状态图构建Step3：使用while+switch双循环将DFA代码化主程序流程各程序模块之间层次关系主要变量说明实验结果源码 实验目的 学习和掌握词法分析程序手工构造状态图及其代码实现方法。 实验任务 （1）阅读已有编译器的经典词法分析源程序； （2）用C或C++语言编写一门...
编译原理Lab1-用FLEX构造C-Minus-f词法分析器
m0_56147044的博客
11-23 883
编译原理实验报告lab1-利用FLEX构造C-Minus-f词法分析器
笔记-编译原理-实验一-词法分析器设计
31415926535x的博客
04-07 2229
第一次实验 词法分析实验报告 设计思想 词法分析的主要任务是根据文法的词汇表以及对应约定的编码进行一定的识别，找出文件中所有的合法的单词，并给出一定的信息作为最后的结果，用于后续语法分析程序的使用；本实验针对 PL/0 语言 的文法、词汇表编写一个词法分析程序，对于每个单词根据词汇表输出： (单词种类, 单词的值) 二元对。 词汇表： 种别编码 单词符号 助记符 0 begin b...
编译原理——词法分析器 C++实现
weixin_45693492的博客
04-12 2万+
词法分析器实验目的单词分类表单词结构描述单词状态转换图算法描述程序结构源代码实验结果 实验目的 对C语言的一个子集设计并实现一个简单的词法分析器，掌握利用状态转换图设计词法分析器的基本方法。利用该词法分析器完成对源程序字符串的词法分析。 培养团队合作精神，体会协同工作在解决问题中的作用。 单词分类表 单词符号 种类 种别码 单词符号 种类 种别码 未定义符号 未定义符号 0 =...
【编译原理】词法分析器的设计与实现
最新发布
记录我的学习历程
05-25 1419
具体描述识别过程时，识别单词的算法一般会根据编程语言的词法规则进行设计，通过状态机、正则表达式等方式来实现各种单词的识别。扩展词法分析器的功能可以通过添加更多的词法规则和相应的分类逻辑来实现，从而适应更复杂的编程语言要求。outFile
编译原理课程作业-Cminus语言的词法及语法分析器实现
Janspiry
10-14 6147
Cminus Compiler 编译原理课程作业-Cminus语言的词法及语法分析器实现 设计思想 词法分析 使用确定有限态自动机（DFA）实现与Lex自动分析两种方式实现。 语法分析 使用递归下降方式与Yacc自动分析两种方式实现。 程序部分代码使用STL简化设计，对于重复部分使用自定义结构体或者全局函数进行重构。 设计思路 手工方式 词法分析： 首先通过分析词法规则，使用手工的方式构造DFA，自定义结构体记录每个状态节点的状态，节点的分为接受与非接受多个状态，同时接受态又分为文件结束、保留字，ID等多个
词法分析器C++实现
hjy9494的博客
03-03 1223
编译原理词法分析器
编译原理上机 - 函数绘图语言(1) - 词法分析器 - C++代码(完整代码在结尾)
dearliyiyang的博客
11-19 2124
西电 编译原理 函数绘图语言解释器 上机代码
词法分析-C-Minus代码.zip_C-Minus_词法分析-C-Minus代码_词法分析实验
09-23
通过提供一些测试用例，我们可以确保词法分析器能够正确地识别和处理各种C-Minus语言的记号。 在实现词法分析器时，通常会涉及以下步骤： - 读取源代码字符流。 - 应用正则表达式或NFA/DFA来识别记号。 - 分析连续...
C_minus语言词法分析器的设计
08-19
总之，《C_minus语言词法分析器的设计》实验不仅加深了对编译原理中词法分析阶段的理解，而且通过具体实现提高了编程技巧，特别是在状态转换图的构建和高级语言的应用方面。实验结果证明，精心设计的词法分析器能够...
C-Minus编译器 编译原理实验
05-14
参照TINY语法分析器的实现，运用所学知识用C语言或者C++语言实现C-MINUS词法分析器,可输出token，再在词法分析的基础上实现C-MINUS语法分析器，可输出语法树。 本资源是运用自顶向下方法中的递归下降分析方法进行...
SOCKET编程（C语言实现）
hiluo302的博客
07-19 2万+
一，基本步骤 TCP server端实现 1，建立socket套接字 2，绑定套接字（指定ip和端口号） 3，listen（进入监听状态） 4，accept接受客户端请求 5，收发数据 5，关闭套接字TCP client端实现 1，建立socket套接字 2，connect连接服务器套接字（指定服务器ip和端口号） 3，收发数据 4，关闭套接字注意：在TCP连接中，client
python使用arima进行预测predict函数
hiluo302的博客
07-05 1万+
y = pd.Series([1,2,1,2]) arima = ARIMA(y, order=(0, 0, 1)).fit() print(arima.summary()) plt.figure() plt.plot(y) plt.plot(arima.fittedvalues, color='red') plt.plot(arima.forecast(3), color='blue') plt.legend() plt.show() y的index从0到3，arima.predict(0,3) ==
编译原理——Tiny词法分析器c++实现
hiluo302的博客
04-28 4145
Tiny语言和c-相比更为简单，在实现的时候，对文本的读取，发现回车换行是一个头疼的问题，fgetc（）函数和fseek（）函数并不是一一对应的。fseek（）会回车换行算两个字符，而fgetc（）读到’\r’或’\n’其中一个都会返回’\n’，也就是说把回车换行符当作一个字符。代码如下：#include <iostream> #include <stdio.h> #include <stdlib.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值