编译原理实验一：词法分析程序设计实验

最新推荐文章于 2024-05-08 08:26:47 发布
最新推荐文章于 2024-05-08 08:26:47 发布
阅读量1.4k 收藏 8
点赞数 1
分类专栏： 编译原理 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoxiaobao1207/article/details/121042574
版权

编译原理实验一

结果（只是基础实验还没做拓展实验，我太喜欢这个风格的vscode了，多贴一次哈哈哈哈哈）

在这里插入图片描述

对实验指导书源程序进行一些补充和少量修改

程序一：

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#define ID 7
#define INT 8
#define REAL 9
#define LT 10
#define LE 11
#define EQ 12
#define NE 13
#define GT 14
#define GE 15
#define IS 16
#define PL 17
#define MI 18
#define MU 19
#define DI 20

char TOKEN[20];
void report_error(char *s)
{
    printf("Having Error: %s", *s);
}
void out(int x, char *s)
{
    switch (x)
    {
    case 7:
    {
        printf("%s,%s\n", "ID", s);
        break;
    }
    case 8:
    {
        printf("%s,%s\n", "INT", s);
        break;
    }
    case 10:
    {
        printf("%s,%s\n", "LT", s);
        break;
    }
    case 11:
    {
        printf("%s,%s\n", "LE", s);
        break;
    }
    case 12:
    {
        printf("%s,%s\n", "EQ", s);
        break;
    }
    case 13:
    {
        printf("%s,%s\n", "NE", s);
        break;
    }
    case 14:
    {
        printf("%s,%s\n", "GT", s);
        break;
    }
    case 15:
    {
        printf("%s,%s\n", "GE", s);
        break;
    }
    case 16:
    {
        printf("%s,%s\n", "IS", s);
        break;
    }
    case 17:
    {
        printf("%s,%s\n", "PL", s);
        break;
    }
    case 18:
    {
        printf("%s,%s\n", "MI", s);
        break;
    }
    case 19:
    {
        printf("%s,%s\n", "MU", s);
        break;
    }
    case 20:
    {
        printf("%s,%s\n", "DI", s);
        break;
    }
    default:
    {
        printf("%s,%s\n", KeyWordTable[x], s);
        break;
    }
    }
}

/* 建立保留字表 */
#define MAX_KEY_NUMBER 20                         /*关键字的数量*/
#define KEY_WORD_END "waiting for your expanding" /*关键字结束标记*/
char *KeyWordTable[MAX_KEY_NUMBER] = {"begin", "end", "if", "then", "else", "switch", "case", KEY_WORD_END};
/* 查保留字表，判断是否为关键字 
不是关键字，返回0，是关键字，返回n+1, n为关键字数组中所找到的相同的关键字的索引位置*/
int lookup(char *token)
{
    int n = 0;
    while (strcmp(KeyWordTable[n], KEY_WORD_END)) /*如果比较到最后一位，也就是KEY_WORD_END,也就是已经确定都没有相同的，返回0*/
    {
        /*strcmp比较两串是否相同，若相同返回0*/
        /*相等：strcmp函数返回0，加上！后为：TRUE 进入if内部执行语句；
        不相等： strcmp返回其他正数或负数，这些返回值都等价于：TRUE ，加上！后，都为：FALSE 不进入if内部语句*/
        if (!strcmp(KeyWordTable[n], token))
        {
            return n + 1; /*根据单词分类码表I，设置正确的关键字类别码，并返回此类别码的值*/
            break;
        }
        n++;
    }
    return 0; /*单词不是关键字，而是标识符*/
}

void scanner_example(FILE *fp)
{
    char ch;
    int i = 0;
    int c = 0;
    ch = fgetc(fp); /*取出一个字符*/

    /*首字符为字母，字母数字混杂*/
    if (isalpha(ch)) /*是否是字母*/
    {
        TOKEN[0] = ch;
        ch = fgetc(fp); /*取出下一个字符*/
        i = 1;
        while (isalnum(ch)) /*是否是字母或者数字*/
        {
            TOKEN[i] = ch;
            i++;
            ch = fgetc(fp); /*取出一个字符*/
        }
        /*跳出循环之后，fp指针指向的字符，不再是数字或者字母*/
        TOKEN[i] = '＼0';
        fseek(fp, -1, 1);  /*fp指针从当前位置往前挪一位*/
        c = lookup(TOKEN); /*判断是否是关键字，不是的话返回0*/
        if (c == 0)
            out(ID, TOKEN);
        else
            out(c - 1, " "); /*因为lookup函数返回值为n+1*/
    }
    /*首字符是数字，整型数字*/
    else if (isdigit(ch)) /*是否是数字*/
    {
        TOKEN[0] = ch;
        ch = fgetc(fp); /*取出第二个字符*/
        i = 1;
        while (isdigit(ch)) /*后面取出的字符都依然是数字*/
        {
            TOKEN[i] = ch;
            i++;
            ch = fgetc(fp);
        }
        /*跳出循环之后，fp指针指向的字符，不再是数字*/
            TOKEN[i] = '＼0';
            fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
            out(INT, TOKEN);
    }
    else
    {
        switch (ch)
        {
        case '<':
        {
            ch = fgetc(fp);
            if (ch == '=')
                out(LE, " ");
            else if (ch == '>')
                out(NE, " ");
            else
            {                     /*下一位不是=或者> ：当做只有< */
                fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
                out(LT, " ");
            }
            break;
        }
        case '=':
        {
            out(EQ, " ");
            break;
        }
        case '>':
        {
            ch = fgetc(fp);
            if (ch == '=')
                out(GE, " ");
            else
            {                     /*下一位不是= ：当做只有> */
                fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
                out(GT, " ");
            }
            break;
        }
        case ':':
        {
            ch = fgetc(fp);
            if (ch == '=')
            {
                out(IS, " ");
            }
            else
            { /*冒号后面跟着的不是等号的话*/
                report_error(":");
                fseek(fp, -1, 1);
            }
        }
        case '+':
        {
            out(PL, " ");
        }
        case '-':
        {
            out(MI, " ");
        }
        case '*':
        {
            out(MU, " ");
        }
        case '/':
        {
            out(DI, " ");
        }
        default:
        {
            report_error(&ch);
            break;
        }
        }
    }

    return;
}

程序二

#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include<stdlib.h>

#define DIGIT 1
#define POINT 2
#define OTHER 3
#define POWER 4
#define PLUS  5
#define MINUS 6
#define UCON  7 
/*Suppose the class number of unsigned constant is 7
假设无符号常量的类数为7*/
#define ClassOther 200
#define EndState -1
int w, n, p, e, d;
int Class; 
/*Used to indicate class of the word
用来表示单词的类别*/
int ICON;
float FCON;
static int CurrentState; 
/*Used to present current state, the initial value:0
用于表示当前状态，初始值：0*/

int GetChar(void);
int EXCUTE(int, int);
int HandleOtherWord(void)
{
    return ClassOther;
}
int HandleError(void)
{
    printf("Error!＼n");
    return 0;
}

int GetChar(void)
{
    int c;
    c = getchar();
    if (isdigit(c))
    {
        d = c -'0';
        return DIGIT;
    }
    if (c =='.')
        return POINT;
    if (c =='E'|| c =='e')
        return POWER;
    if (c =='+')
        return PLUS;
    if (c =='-')
        return MINUS;
    return OTHER;
}
int EXCUTE(int state, int symbol)
{
    switch (state)
    {
    case 0:
        switch (symbol)
        {
        case DIGIT:
            n = 0;
            p = 0;
            e = 1;
            w = d;
            CurrentState = 1;
            Class = UCON;
            break;
        case POINT:
            w = 0;
            n = 0;
            p = 0;
            e = 1;
            CurrentState = 3;
            Class = UCON;
            break;
        default:
            HandleOtherWord();
            Class = ClassOther;
            CurrentState = EndState;
        }
        break;
    case 1:
        switch (symbol)
        {
        case DIGIT:
            w = w * 10 + d;
            break; //CurrentState=1
        case POINT:
            CurrentState = 2;
            break;
        case POWER:
            CurrentState = 4;
            break;
        default:
            ICON = w;
            CurrentState = EndState;
        }
        break;
    case 2:
        switch (symbol)
        {
        case DIGIT:
            n++;
            w = w * 10 + d;
            break;
        case POWER:
            CurrentState = 4;
            break;
        default:
            FCON = w * pow(10, e * p - n);
            CurrentState = EndState;
        }
        break;
    case 3:
        switch (symbol)
        {
        case DIGIT:
            n++;
            w = w * 10 + d;
            CurrentState = 2;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 4:
        switch (symbol)
        {
        case DIGIT:
            p = p * 10 + d;
            CurrentState = 6;
            break;
        case MINUS:
            e = -1;
            CurrentState = 5;
            break;
        case PLUS:
            CurrentState = 5;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 5:
        switch (symbol)
        {
        case DIGIT:
            p = p * 10 + d;
            CurrentState = 6;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 6:
        switch (symbol)
        {
        case DIGIT:
             p = p * 10 + d;
            break;
        default:
            FCON = w * pow(10, e * p - n);
            CurrentState = EndState;
        }
        break;
    }
    return CurrentState;
}
int LEX(void)
{
    int ch;
    CurrentState = 0;
    while (CurrentState != EndState)
    {
        ch = GetChar();
        EXCUTE(CurrentState, ch);
    }
    fseek(fp,-1,1);
    //return Class;
    printf("w: %d  n: %d  p: %d  e: %d  d: %d", w, n, p, e, d);
    printf("\n ICON: %.3f, FCON: %.3f CLASS: %d", ICON, FCON, Class);
}
int main(){
    LEX();
    system("pause");
}

写实验二的时候找到的实验一的一个逻辑错误

在这里插入图片描述

一开始没有写这句回退fp指针，结果就是： “字符c实数字符a字符b”这样的字符串在判断的时候，会在识别出实数之后把fp指针向后多走一位，这样字符A就根本没有被识别的机会，这个事情是在实验二识别基础算术表达式的时候发现的

但是程序二是建立在手动输入上的，需要将程序一二做一个合体，读取同一个文件

所以最终程序 ：

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#define ID 7
#define INT 8
#define REAL 9
#define LT 10
#define LE 11
#define EQ 12
#define NE 13
#define GT 14
#define GE 15
#define IS 16
#define PL 17
#define MI 18
#define MU 19
#define DI 20

/****************************判断实数**************************************/
#define DIGIT 1
#define POINT 2
#define OTHER 3
#define POWER 4
#define PLUS 5
#define MINUS 6
#define UCON 7
/*Suppose the class number of unsigned constant is 7
假设无符号常量的类数为7*/
#define ClassOther 200
#define EndState -1
int w, n, p, e, d;
int Class;
/*Used to indicate class of the word
用来表示单词的类别*/
int ICON;
float FCON;
static int CurrentState;
/*Used to present current state, the initial value:0
用于表示当前状态，初始值：0*/
int GetChar(void);
int EXCUTE(int, int);
int HandleOtherWord(void)
{
    return ClassOther;
}
int HandleError(void)
{
    printf("Error!＼n");
    return 0;
}

int GetChar(FILE *fp)
{
    int c;
    c = fgetc(fp);
    if (isdigit(c))
    {
        d = c - '0';
        return DIGIT;
    }
    if (c == '.')
        return POINT;
    if (c == 'E' || c == 'e')
        return POWER;
    if (c == '+')
        return PLUS;
    if (c == '-')
        return MINUS;
    return OTHER;
}
int EXCUTE(int state, int symbol)
{
    switch (state)
    {
    case 0:
        switch (symbol)
        {
        case DIGIT:
            n = 0;
            p = 0;
            e = 1;
            w = d;
            CurrentState = 1;
            Class = UCON;
            break;
        case POINT:
            w = 0;
            n = 0;
            p = 0;
            e = 1;
            CurrentState = 3;
            Class = UCON;
            break;
        default:
            HandleOtherWord();
            Class = ClassOther;
            CurrentState = EndState;
        }
        break;
    case 1:
        switch (symbol)
        {
        case DIGIT:
            w = w * 10 + d;
            break; //CurrentState=1
        case POINT:
            CurrentState = 2;
            break;
        case POWER:
            CurrentState = 4;
            break;
        default:
            ICON = w;
            CurrentState = EndState;
        }
        break;
    case 2:
        switch (symbol)
        {
        case DIGIT:
            n++;
            w = w * 10 + d;
            break;
        case POWER:
            CurrentState = 4;
            break;
        default:
            FCON = w * pow(10, e * p - n);
            CurrentState = EndState;
        }
        break;
    case 3:
        switch (symbol)
        {
        case DIGIT:
            n++;
            w = w * 10 + d;
            CurrentState = 2;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 4:
        switch (symbol)
        {
        case DIGIT:
            p = p * 10 + d;
            CurrentState = 6;
            break;
        case MINUS:
            e = -1;
            CurrentState = 5;
            break;
        case PLUS:
            CurrentState = 5;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 5:
        switch (symbol)
        {
        case DIGIT:
            p = p * 10 + d;
            CurrentState = 6;
            break;
        default:
            HandleError();
            CurrentState = EndState;
        }
        break;
    case 6:
        switch (symbol)
        {
        case DIGIT:
            p = p * 10 + d;
            break;
        default:
            FCON = w * pow(10, e * p - n);
            CurrentState = EndState;
        }
        break;
    }
    return CurrentState;
}
int LEX(FILE *fp)
{
    int ch;
    CurrentState = 0;
    while (CurrentState != EndState)
    {
        ch = GetChar(fp);
        EXCUTE(CurrentState, ch);
    }
    fseek(fp,-1,1);
    /*printf("\nw: %d  n: %d  p: %d  e: %d  d: %d", w, n, p, e, d);*/
    /*printf("\n ICON: %.3f, FCON: %.3f CLASS: %d\n\n", ICON, FCON, Class);*/
    printf("REAL, %.3f\n", FCON);
}

/***********************************判断实数***********************************/



/************************************判断是否是保留字********************************/
/* 建立保留字表 */
#define MAX_KEY_NUMBER 20                         /*关键字的数量*/
#define KEY_WORD_END "waiting for your expanding" /*关键字结束标记*/
char *KeyWordTable[MAX_KEY_NUMBER] = {"begin", "end", "if", "then", "else", "switch", "case", KEY_WORD_END};
/* 查保留字表，判断是否为关键字 
不是关键字，返回0，是关键字，返回n+1, n为关键字数组中所找到的相同的关键字的索引位置*/
int lookup(char *token)
{
    int n = 0;
    while (strcmp(KeyWordTable[n], KEY_WORD_END)) /*如果比较到最后一位，也就是KEY_WORD_END,也就是已经确定都没有相同的，返回0*/
    {
        /*strcmp比较两串是否相同，若相同返回0*/
        /*相等：strcmp函数返回0，加上！后为：TRUE 进入if内部执行语句；
        不相等： strcmp返回其他正数或负数，这些返回值都等价于：TRUE ，加上！后，都为：FALSE 不进入if内部语句*/
        if (!strcmp(KeyWordTable[n], token))
        {
            return n + 1; /*根据单词分类码表I，设置正确的关键字类别码，并返回此类别码的值*/
            break;
        }
        n++;
    }
    return 0; /*单词不是关键字，而是标识符*/
}
/************************************判断是否是保留字***************************************/




/**********************************非实数的所有显示与报错*********************************************/
void report_error(char *s)
{
    printf("Having Error：%s\n",s);
}
void out(int x, char *s)
{
    switch (x)
    {
    case 7:
    {
        printf("%s,%s\n", "ID", s);
        break;
    }
    case 8:
    {
        printf("%s,%s\n", "INT", s);
        break;
    }
    case 10:
    {
        printf("%s,%s\n", "LT", s);
        break;
    }
    case 11:
    {
        printf("%s,%s\n", "LE", s);
        break;
    }
    case 12:
    {
        printf("%s,%s\n", "EQ", s);
        break;
    }
    case 13:
    {
        printf("%s,%s\n", "NE", s);
        break;
    }
    case 14:
    {
        printf("%s,%s\n", "GT", s);
        break;
    }
    case 15:
    {
        printf("%s,%s\n", "GE", s);
        break;
    }
    case 16:
    {
        printf("%s,%s\n", "IS", s);
        break;
    }
    case 17:
    {
        printf("%s,%s\n", "PL", s);
        break;
    }
    case 18:
    {
        printf("%s,%s\n", "MI", s);
        break;
    }
    case 19:
    {
        printf("%s,%s\n", "MU", s);
        break;
    }
    case 20:
    {
        printf("%s,%s\n", "DI", s);
        break;
    }
    default:
    {
        printf("%s,%s\n", KeyWordTable[x], s);
        break;
    }
    }
}
/**********************************非实数的所有显示与报错*********************************************/



/**********************************扫描一次*********************************************/
void scanner_example(FILE *fp)
{
    char TOKEN[20] = {};
    char ch;
    int i = 0;
    int c = 0;
    ch = fgetc(fp); /*取出一个字符*/

    /*首字符为字母，字母数字混杂*/
    if (isalpha(ch)) /*是否是字母*/
    {
        TOKEN[0] = ch;
        ch = fgetc(fp); /*取出下一个字符*/
        i = 1;
        while (isalnum(ch)) /*是否是字母或者数字*/
        {
            TOKEN[i] = ch;
            i++;
            ch = fgetc(fp); /*取出一个字符*/
        }
        /*跳出循环之后，fp指针指向的字符，不再是数字或者字母*/
        fseek(fp, -1, 1);  /*fp指针从当前位置往前挪一位*/
        c = lookup(TOKEN); /*判断是否是关键字，不是的话返回0*/
        if (c == 0)
            out(ID, TOKEN);
        else
            out(c - 1, " "); /*因为lookup函数返回值为n+1*/
    }
    /*首字符是数字，整型数字*/
    else if (isdigit(ch)) /*是否是数字*/
    {
        TOKEN[0] = ch;
        ch = fgetc(fp); /*取出第二个字符*/
        i = 1;
        while (isdigit(ch)) /*后面取出的字符都依然是数字*/
        {
            TOKEN[i] = ch;
            i++;
            ch = fgetc(fp);
        }
        /*跳出循环之后，fp指针指向的字符，不再是数字*/
        if (ch != 'E' && ch != 'e' && ch != '.')
        {
            fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
            out(INT, TOKEN);
        }
        else /*考虑实型常数*/
        {
            fseek(fp, -(i + 1), 1);
            LEX(fp);
        }
    }
    else
    {
        switch (ch)
        {
        case '<':
        {
            ch = fgetc(fp);
            if (ch == '=')
                out(LE, " ");
            else if (ch == '>')
                out(NE, " ");
            else
            {                     /*下一位不是=或者> ：当做只有< */
                fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
                out(LT, " ");
            }
            break;
        }
        case '=':
        {
            out(EQ, " ");
            break;
        }
        case '>':
        {
            ch = fgetc(fp);
            if (ch == '=')
                out(GE, " ");
            else
            {                     /*下一位不是= ：当做只有> */
                fseek(fp, -1, 1); /*fp指针从当前位置往前挪一位*/
                out(GT, " ");
            }
            break;
        }
        case ':':
        {
            ch = fgetc(fp);
            if (ch == '=')
            {
                out(IS, " ");
            }
            else
            { /*冒号后面跟着的不是等号的话*/
                report_error(":");
                fseek(fp, -1, 1);
            }
            break;
        }
        case '+':
        {
            out(PL, " ");
            break;
        }
        case '-':
        {
            out(MI, " ");
            break;
        }
        case '*':
        {
            out(MU, " ");
            break;
        }
        case '/':
        {
            out(DI, " ");
            break;
        }
        case ' ':
        {
            break;
        }
        case '\n':
        { 
            break;
        } 
        default:
        {
            report_error(&ch);
            break;
        }
        }
    }

    return;
}
/**********************************扫描一次*********************************************/




int main()
{
    FILE *fp = NULL;
    fp = fopen("Test.txt", "r");
    char ch;
    while (1)
    {
        ch = fgetc(fp);
        if (ch != EOF)
        {
            fseek(fp, -1, 1);
        }
        else
        {
            break;
        }
        scanner_example(fp);
    }
    fclose(fp);
    system("pause");
}

在这里插入图片描述

ALAN_CF
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言基础——输入输出及string操作
qq_42948022的博客
12-05 990
输出printf与put #include <iostream> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <ctype.h> #include <math.h> int main() { /* stdio.h常用函数 */ i...
算法笔记上面的例子-C++入门-------过程记录
zxmfly888的博客
07-16 167
1.头文件 c程序 #include<stdio.h> //standard input output h是head的缩写 #include<string.h> #include<math.h> c++程序 #include<cstdio> #include<cmath> #include<cstring> 2.主函数 ...
编译原理——词法分析程序
最新发布
m0_74219898的博客
05-08 965
分程序>→[<常量说明部分>][<变量说明部分>][<过程说明部分>]<复合语句><语句>→<赋值语句>|<条件语句>|<当型循环语句>|<过程调用语句><过程说明部分>→<过程首部><分程序>；{<过程首部><分程序>；<常量说明部分>→CONST<常量定义>{，<常量定义>}；<条件>→<表达式><关系运算符><表达式> | ODD<表达式><写语句>→WRITE(<表达式>{，<表达式>})<表达式>→[+|-]<项>{<加型运算符><项>}<当型循环语句>→WHILE<条件>DO<语句>
编译原理实验一 《词法分析程序设计与实现》
Atlas
05-03 1万+
编译原理实验一 《词法分析程序设计与实现》 一、实验目的 ​加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。 二、实验内容 自定义一种程序设计语言，或者选择已有的一种高级语言，编制它的词法分析程序。词法分析程序的实现可以采用任何一种编程语言和编程工具。从输入的源程序中，识别出各个具有独立意义的单词，即关键字、标识符、常数、运算符、界符。并依次输出各个单词的内部编码及单词符号自身值。（遇到错误时可显示
编译原理实验一【词法分析程序设计】
今天你AC了吗
12-30 4796
基本要求： ①掌握程序语言的词法结构。 ②掌握状态转换图的使用。 ③掌握设计词法分析程序的一般方法。 ④学会熟练调式程序。 重点及难点：掌握用状态转换图描述程序词法结构的一般方法，并在此基础上完成简版C语言子集词法分析程序的设计和调试运行。 一、 C语言子集的单词符号表示 一个非常重要的事实是：大多数程序语言的单词符号都可以用状态转换图予以识别。作为本次实验，我们来构造一个C语言子集的简单词法分析器。下表列出了这个C语言子集的所有单词符号以及它们的种别编码和内码值。由于直接使用整数编码不利于记忆，故该程序中
c语言------期末考试编程练习题
qq_48566899的博客
03-24 209
c
编译原理实验：词法分析程序设计与实现/NFA确定化为DFA的算法实现
10-28
编译原理实验：词法分析程序设计与实现。对一个简单语言的子集编制一个一遍扫描的词法分析程序；构造一程序，实现：将给定的NFA M( 其状态转换矩阵及初态、终态信息保存在指定文件中)确定化为 DFA M，输出 DFA M 其...
实验编译原理词法分析程序设计方案样本.doc
11-21
"实验编译原理词法分析程序设计方案样本.doc" 本实验的主要目的是设计一个词法分析程序，用于扫描S语言源程序，产生单词二元式，并输出到目的文献中。本设计方案样本将详细介绍实验的设计思路、实现步骤和关键技术...
编译原理实验报告(一)词法分析程序.doc
03-20
在这个实验报告中，我们关注的是针对C语言的词法分析程序，它实现了对源代码文件的扫描，并将源程序分解为关键字、标识符、常量和运算符四种词类。 实验目标是加深对词法分析原理的理解，并掌握如何在源程序中识别...
编译原理实验报告-词法分析
01-14
《编译原理实验报告-词法分析》 在编译领域，词法分析是构建编译器的关键步骤之一，它负责将源代码分解成一个个独立的、有意义的符号，即“单词”或“记号”。本实验的目标在于帮助学生深入理解词法分析在编译程序...
编译原理实验1——词法分析器设计
07-08
本次实验主要关注的是词法分析器的设计，这是编译器的第一个阶段，也称为扫描器。词法分析器的任务是从源代码中识别出一个个有意义的单元，称为记号（Token），为后续的语法分析做准备。 在这个实验中，我们将使用...
词法分析器实验报告.doc
05-09
本次实验通过用python语言，设计，编制，调试一个词法分析子程序，识别单词，实现一个python词法分析器，经过此过程可以加深对编译器解释单词流的过程。
C语言：6_6上机题
小柒的秃头之路
07-25 107
#include <stdio.h> #include <assert.h> #include <malloc.h> #include <ctype.h> #include <string.h> void Vowel(char *des, const char *src) { assert(des != NULL && src != NULL); if(des == NULL || src == NULL) return.
2022-03-26_单链表实现队列(带目录版)
qq_43205256的博客
03-27 1372
一、创建三个文件 二、代码实现 1.Queue.c部分 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> #include <time.h> #include <errno.h> #include <ctype.h> #inclu...
编译原理实验一：词法分析程序设计与实现
ReadyGo!!!的博客
10-28 8034
一、实验内容 假定一种高级程序设计语言中的单词主要包括关键字begin、end、if、else、switch、case；标识符；整型常数；实型常数；六种关系运算符；一个赋值符和四个算术运算符，试构造能识别这些单词的词法分析程序（二十类单词的分类码参见表1）。 输入：由符合和不符合所规定的单词类别结构的各类单词组成的源程序文件。 输出：把所识别出的每一单词均按形如（CLASS，VALUE）的二元式形式输出，并将结果放到某个文件中。对于标识符和常数，CLASS字段为相应的类别码的助记符；VALUE字段则是该.
编译原理——设计一个词法分析程序,实现对C程序设计语言的源程序（自定）的词法分析
雨云21的博客
03-13 9158
设计并实现一个词法分析器，实现对自己输入的类C语言源程序中的所有单词进行分类，指出其所属类型，实现简单的词法分析操作。
2022-02-18_文件的打开和关闭
qq_43205256的博客
03-10 485
一、 作业标题 通讯录 作业内容 1.实现通讯录的增删查改 2.实现通讯录数据可以保存到文件，也可以从文件中加载数据。 第一步、创建头文件和源文件 第二步、编程实现 text.c部分 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> #include &lt.
编译原理实验1--词法分析
weixin_45829101的博客
07-09 5284
编译原理实验1–词法分析 BY --ELFer 实验目的 设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。并依次输出各个单词的内部编码及单词符号自身值。 实验内容 回顾词法分析的过程，明确要区分出保留字、标识符、常数、运算符、分隔符五大类单词的哪些词，确定每类的种别码。 针对每一类单词，设计程序，
编译原理实验1———简单词法分析程序
m0_62616221的博客
12-12 1050
简单词法分析程序
【编译原理】词法分析（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，设计并实

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值