实验二 词法分析器的实现

最新推荐文章于 2024-05-25 10:36:02 发布
最新推荐文章于 2024-05-25 10:36:02 发布
阅读量6.9k 收藏 19
点赞数 4
分类专栏： -------编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tangyuanzong/article/details/78578185
版权

这里定义了一个编程语言称作C－M i n u s (或简称为C－)，这是一种适合编译器设计方案的
语言，它比T I N Y语言更复杂，包括函数和数组。本质上它是C的一个子集，但省去了一些重要
的部分，因此得名。这个附录由5小节组成。首先，我们列出了语言惯用的词法，包括语言标
记的描述。其次，给出了每个语言构造的B N F描述，同时还有相关语义的英语描述。在A . 3节，
给出了C－的两个示例程序。再者，描述了C－的一个Tiny Machine运行时环境。最后一节描述
了一些使用C－和T M的编程设计方案，适合于一个编译器教程。

C－惯用的词法

  1. 下面是语言的关键字：
 else if int return void while

所有的关键字都是保留字，并且必须是小写。
2. 下面是专用符号：

+ - * / < <= > >= == != = ; , ( ) [ ] { } /* */
  1. 其他标记是I D和N U M，通过下列正则表达式定义：
ID = letter letter*
NUM = digit digit*
letter = a|..|z|A|..|Z
digit = 0|..|9

小写和大写字母是有区别的。
4. 空格由空白、换行符和制表符组成。空格通常被忽略，除了它必须分开I D、N U M关键字。
5. 注释用通常的C语言符号/ * … * /围起来。注释可以放在任何空白出现的位置(即注释不能放在标记内)上，且可以超过一行。注释不能嵌套。

词法分析器的DFA：

这里写图片描述

源码实现：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<string>
#include<iostream>
#define intputfile "test.c"
#define outputfile "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;
    fseek(source,-len,1);//文件指针回退
    for(int i=0;i<len;i++) s[i]=fgetc(source);
    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 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 comment(char ch,int i)
{
    bool isexit = false; //当不是注释时用于跳出循环
    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 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 Scanner()
{
    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);
    }
}

bool read(){
   if(((source=fopen(intputfile,"r"))==NULL)||((target=fopen(outputfile,"w"))==NULL))
    return 0;
    return 1;
}
int main()
{
    if(!read()){
        printf("文件打开失败!");
        exit(0);
    }
    Scanner();  //开始扫描文件 entrance
    fclose(source);
    fclose(target);
    return 0;
}

输入文件：

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));
}

输出文件：

<RESW,int>
<FUCN,gcd>
<OP,(>
<RESW,int>
<ID,u>
<OP,,>
<RESW,int>
<ID,v>
<OP,)>
<OP,{>
<RESW,if>
<OP,(>
<ID,v>
<OP,==>
<NUM,0>
<OP,)>
<RESW,return>
<ID,u>
<OP,;>
<RESW,else>
<RESW,return>
<FUCN,gcd>
<OP,(>
<ID,v>
<OP,,>
<ID,u>
<OP,->
<ID,u>
<OP,/>
<ID,v>
<OP,*>
<ID,v>
<OP,)>
<OP,;>
/* u-u/v*v == u mod v */
<OP,}>
<RESW,void>
<FUCN,main>
<OP,(>
<RESW,void>
<OP,)>
<OP,{>
<RESW,int>
<ID,x>
<OP,;>
<RESW,int>
<ID,y>
<OP,;>
<ID,x>
<OP,=>
<FUCN,input>
<OP,(>
<OP,)>
<OP,;>
<ID,y>
<OP,=>
<FUCN,input>
<OP,(>
<OP,)>
<OP,;>
<FUCN,output>
<OP,(>
<FUCN,gcd>
<OP,(>
<ID,x>
<OP,,>
<ID,y>
<OP,)>
<OP,)>
<OP,;>
<OP,}>
计算机的小粽子
关注
  • 4
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
编译原理实验1-词法分析器实现
weixin_45428457的博客
02-23 1240
编译原理，词法分析
实验二 词法分析程序设计
水瓶KaKei的博客
07-12 887
实验内容 TINY 语言的词法由TINY Syntax.ppt 描述； TINY 语言的词法分析器由TINY Scanner.rar 的C 语言代码实现； TINY+语言的词法由TINY+ Syntax.doc 描述。 任务：理解TINY 语言的词法及词法分析器的实现，并基于该词法分析器， 实现拓展语言TINY+的词法分析器。
【编译原理】词法分析器的设计与实现
最新发布
记录我的学习历程
05-25 1424
具体描述识别过程时，识别单词的算法一般会根据编程语言的词法规则进行设计，通过状态机、正则表达式等方式来实现各种单词的识别。扩展词法分析器的功能可以通过添加更多的词法规则和相应的分类逻辑来实现，从而适应更复杂的编程语言要求。outFile
编译原理 实验一 词法分析器
热门推荐
just_a_new_life
07-03 10万+
编写一个词法分析程序
实验二利用自动机理论实现词法分析器
weixin_45683054的博客
05-31 1521
实验二利用自动机理论实现词法分析器 1．实验目的熟悉词法分析阶段的要求，掌握利用自动机理论实现词法分析器的方法。 2．实验设备硬件：PC 机一台软件：Windows 系统，高级语言集成开发环境3．实验内容根据词法要求采用自动机理论实现词法分析器4．实验要求及步骤注：1、实现语言不限，推荐使用C语言，不可用脚本类语言；2、不允许使用任何语言的正规式控件实现实验要求。根据改状态图写代码 运行截图：代码中Array 和CheckCore 函数参考学长的，如有侵权联系我删除
编译原理实验二 词法分析【C语言实现】
小凯的博客
11-27 3064
编译原理实验二词法分析、C语言实现
编译原理 实验一 词法分析器设计
cos的博客
04-08 9528
1. 深入理解有限自动机及其应用掌握 2. 根据语言的词法规则构造识别其单词的有限自动机的方法 3. 基本掌握词法分析程序的开发方法 4. 能够设计词法扫描器程序，对源程序进行词法分析，并输出单词序列
郑州大学编译原理实验一词法分析器JAVA
[ 25'h ]
11-04 1641
郑州大学编译原理实验一词法分析器JAVA
【编译原理】 实验二：词法分析器的手动实现(基于状态机的词法分析器)
zombotany的博客
07-08 5150
1.借助词法分析工具Flex或Lex完成（参考教材伪代码） 2.输入：高级语言源代码（如helloworld.c） 3.输出：以二元组表示的单词符号序列。通过设计、编制、调试一个具体的词法分析程序，加深对词法分析原理的理解，并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。大多数程序语言的单词符号都可以用状态转换图进行识别。状态转换图可以用程序实现，最简单的办法就是让每一个状态对应一小段程序。在本实验中，为了识别c语言的源程序，需要首先构造出c语言的子集的单词符号及其内码值。针对字
编译原理 实验二 词法分析程序设计
Ruik@SZTU的博客
05-16 2367
1. 实验内容 ● TINY语言的词法由TINY Syntax.ppt描述； ● TINY语言的词法分析器由TINY Scanner.rar的C语言代码实现； ● TINY+语言的词法由TINY+ Syntax.doc描述。 任务：理解TINY语言的词法及词法分析器的实现，并基于该词法分析器，实现拓展语言TINY+的词法分析器。 要求： （1） TINY+词法分析器以TINY+源代码为输入，输出为识别出的token序列； （2） 词法分析器以最长匹配为原则，例如‘:=’应识别为赋值符号而非单独
c语言词法分析程序实验报告,实验一词法分析程序设计与实现
weixin_33443932的博客
05-17 3160
实验一词法分析程序设计与实现一、实验目的：加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。二、实验内容：自定义一种程序设计语言，或者选择已有的一种高级语言(C语言)，编制它的词法分析程序。词法分析程序的实现可以采用任何一种编程工具。三、实验要求：1. 对单词的构词规则有明确的定义；2. ...
编译原理实验词法分析器
01-02
编译原理实验词法分析器 本实验的目的是设计和实现一个词法分析器，以加深对词法分析过程的理解，并掌握词法分析方法。实验中，我们将使用 C 语言实现一个简单的词法分析器，能够识别和分析 C 语言源程序中的单词...
词法分析器实验报告.doc
05-09
在这个实验报告中，我们关注的是如何使用Python语言实现一个词法分析器，特别是针对C语言的源代码。 1. **实验目标**： 实验的主要目标是理解和掌握词法分析的原理，以及如何使用Python实现词法分析器。通过这个...
编译原理词法分析器及语法分析器实验报告，JAVA实现
06-26
在这个实验中，我们将使用Java语言实现一个词法分析器，并结合简单的语法分析。 首先，词法分析器需要识别并处理保留字。保留字是编程语言中具有特殊含义的词汇，例如实验中提到的`if`、`int`、`for`等，它们的单词...
编译原理实验一——C 语言词法分析器设计与实现
08-29
本实验“C语言词法分析器设计与实现”旨在深入理解词法分析原理，并掌握如何构建一个能正确处理源程序中单词的程序。 在编译原理中，词法分析器（也称为扫描器）是第一个处理源代码的组件。它的主要任务是： 1. **...
实验一 词法分析程序设计与实现
06-20
加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。 1.关键字：if、int、for、while、do、return...
实验一(二) DFA识别字符串
唐源棕的博客
11-09 1万+
代码地址 链接一、实验目的通过本次实验，加深对DFA及其识别的语言的理解，学习对一般的DFA的表达方法与编程实现方法。二、实验任务编写一个C语言程序，模拟实现DFA识别字符串的过程。三、实验内容（1）DFA的输入； （2）DFA的存储与读写； （3）DFA的正确性检查； （4）DFA的语言集列表显示； （5）DFA的规则字符串判定；四、内容说明：（1）DFA的输入： 分别输入DFA的“字符
实验十 LL（1）分析表的构造
唐源棕的博客
12-13 1万+
一、实验目的 学习和掌握FIRST集合、FOLLOW集合的计算，LL（1）分析表的构造方法。 二、实验任务 （1）存储文法； （2）计算给定文法所有非终结符的FIRST集合； （3）计算给定文法所有非终结符的FOLLOW集合； （4）构造该文法的LL（1）文法的分析表并按实验九的文法格式存储； （5）结合实验九，完成完整的LL（1）分析过程。 三、实验内容 （1）确定文法
实验三 NFA确定化和DFA最小化
唐源棕的博客
11-25 9687
（一）NFA–>DFA（2小时）一、实验目的学习和掌握将NFA转为DFA的子集构造法。二、实验任务（1）存储NFA与DFA； （2）编程实现子集构造法将NFA转换成DFA。三、实验内容（1）确定NFA与DFA的存储格式。 要求为3个以上测试NFA准备好相应有限自动机的存储文件。（可利用实验一（二）的基础） （2）用C或JAVA语言编写将NFA转换成DFA的子集构造法的程序。 （3）测试验证程
C语言编译原理实验：词法分析器实现
这个实验是针对C语言的，目标是设计和调试一个词法分析器，以深入理解词法分析的原理，并掌握如何在源程序的扫描过程中识别出各种类型的单词，如保留字、标识符、常数、运算符和分隔符等。实验的具体要求是，输入...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

计算机的小粽子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值