中科大编译原理大作业

最新推荐文章于 2022-12-20 19:42:30 发布
最新推荐文章于 2022-12-20 19:42:30 发布
阅读量2.6k 收藏 6
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40636609/article/details/80272904
版权
## **词法分析**


### 正规式


- letter  -> a|b|c|...|z
- digit -> 0|1|...|9
- number -> digit  digit*
- id -> letter(letter|digit)*


### 确定有限自动机（DFA）


```mermaid
graph LR
A[start]-->S0((0))
S0-->|/|S1((1))
S1-->|b|S8((8))
S8-->|l|S9((9))
S9-->|a|S10((10))
S10-->|n|S11((11))
S11-->|k|S12["return /blank"]
S1-->|i|S2((2))
S2-->|n|S3((3))
S3-->|t|S4["return /int"]
S1-->|s|S5((5))
S5-->|u|S6((6))
S6-->|m|S7["return /sum"]
S0-->|"("|S13["return ("]
S0-->|")"|S14["return )"]
S0-->|"{"|S15["return {"]
S0-->|"}"|S16["return }"]
S0-->|_|S17["return _"]
S0-->|^|S18["return ^"]
S0-->|$|S19["return $"]
S0-->|num|S20["return number"]
S0-->|letter|S21((21))
S21-->|"letter/num"|S21
S21-->|other|S22[return id *]
```


## 语法分析


​ 我的语法分析使用的是递归下降的预测分析（LL(1)）


### 语法分析器代码


```
int match_B() {
while(syn != 13) 
{
if(syn == 4 || syn == 5)
{
if(syn == 4) printf("B -> id\n") ;
if(syn == 5) printf("B -> num\n");
scaner();
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
if(syn == 10 || syn == 13 || syn == 8) return true;  // B -> id/num + }/$
if(syn == 11) //B_
{
scaner();
if(syn == 12)      // B -> B_^
        {
        scaner();
        if(syn == 9)   // B_^{
        {
        scaner();
        if(match_B())  // B_^{B
        {
        //scaner();
        if(syn == 10)  //B_^{B}
        {
        scaner();
        if(syn == 9) {  //B_^{B}{
        scaner();
        if(match_B())  //B_^{B}{B
        {
        // scaner();
        if(syn == 10)  //B_^{B}{B}
        {
        printf("B -> B_^{B}{B} \n");
scaner() ;
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;  //B_^{B}{B} + }/)/$
}
}
}
}
}
}
}
else if(syn == 9)   // B -> B_{
{
scaner();
if(match_B())   // B -> B_{B
{
//scaner();
if(syn == 10) // B -> B_{B}
{
printf("B -> B_{B} \n");
scaner();
if(syn == 1 || syn == 2 || syn ==3 )printf("B -> BB\n") ;
if(syn == 13 || syn == 10 || syn == 8) return true;  // B -> B_{B} + }/)/$
}
}
}
}
else if(syn == 12)  // B -> B^
{
scaner();
if(syn == 9)    // B -> B^{
{
scaner();
if(match_B())  // B -> B^{B
{
//scaner();
if(syn == 10) // B -> B^{B}
{
printf("B -> B^{B} \n");
scaner();
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
if(syn == 13 || syn == 10 || syn == 8) return true;  // B -> B^{B} + }/)/$
}
}
}
}
// else {
// printf("B -> id \n");  // B -> ID
// scaner();
// if(syn == 13 || syn == 10) return true; // B -> ID + $/}
// }
}

    else if(syn == 2) {    // B -> /int
        scaner();
        if(syn == 9) {      // B -> /int{
        scaner();
        if(match_B()) {    // B -> /int{B
        //scaner();
        if(syn == 10) {   // B -> /int{B}
        scaner();
        if(syn == 9) {   // B -> /int{B}{
        scaner() ;
        if(match_B()) {     // B -> /int{B}{B
        //scaner();
        if(syn == 10) {    // B -> /int{B}{B}
        scaner();
        if(syn == 9) {    // B -> /int{B}{B}{
        scaner();
        if(match_B()){   // B -> /int{B}{B}{B
        if(syn != 10)
        scaner();  // B -> /int{B}{B}{B}
        if(syn == 10) {
       
        printf("B -> \\int{B}{B}{B} \n");
        scaner();
        if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;    // B -> /int{B}{B}{B} + }/)/$
        }
        }
        }
        }
        }
        }
        }
        }
        }
    }


    else if(syn == 3) {    // B -> /sum
        scaner();
        if(syn == 9) {      // B -> /sum{
        scaner();
        if(match_B()) {    // B -> /sum{B
        if(syn == 10) {   // B -> /sum{B}
        scaner();
        if(syn == 9) {   // B -> /sum{B}{
        scaner();
        if(match_B()) {     // B -> /sum{B}{B
        if(syn == 10) {    // B -> /sum{B}{B}
        scaner();
        if(syn == 9) {    // B -> /sum{B}{B}{
        scaner();
        if(match_B()){   // B -> /sum{B}{B}{B
        if(syn != 10)
        scaner();
        if(syn == 10) {     // B -> /sum{B}{B}{B}
        printf("B -> \\sum{B}{B}{B} \n");  
scaner();     
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;    // B -> /sum{B}{B}{B} + }/)/$
        }
        }
        }
        }
        }
        }
        }
        }
    }
    }


    else if(syn == 5) {
        // scaner();
        printf("B -> num \n");  
scaner();     
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10) return true;
       
    }


    else if(syn == 1) {
        //scaner();
        printf("B -> \\blank \n");
        scaner();
        if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10) return true;
    }


    else if(syn == 7) {     //B -> (
        scaner();
        if(match_B()) {     //B -> (B
        //scaner();
        if(syn == 8) {     //B -> (B)
        // scaner();
        printf("B -> (B)\n");
scaner();       
        return true;   //B -> (B) + $/}
        }
        else match_B();
        }       
    }
    else if(syn == -1) {
    return false;
}
 }
}
```






## 语法制导翻译


​ 因为我使用了递归下降的LL(1)语法，因此语法执导翻译采用L属性定义的自上而下计算 ，具体内容见源代码文件。


## 运行结果


​ 过程描述：输入文件名，输出归约及编译过程，最后自动打开生成的html文件。若是正确样例，则命令行中输出"success"，若是错误样例，命令行中输出"illegal",并在html文件中输出ERROR at ...(错误位置)。


### 测试样例（test文件）


#### test01.txt


![1525937972153](C:/Users/Boatman/AppData/Local/Temp/1525937972153.png)


![1525938041252](C:/Users/Boatman/AppData/Local/Temp/1525938041252.png)


#### test02.txt


![1525938132700](C:/Users/Boatman/AppData/Local/Temp/1525938132700.png)


![1525938175489](C:/Users/Boatman/AppData/Local/Temp/1525938175489.png)


#### test03.txt


![1525938299929](C:/Users/Boatman/AppData/Local/Temp/1525938299929.png)


![1525938320595](C:/Users/Boatman/AppData/Local/Temp/1525938320595.png)


#### test04.txt


![1525938538946](C:/Users/Boatman/AppData/Local/Temp/1525938538946.png)


![1525938559881](C:/Users/Boatman/AppData/Local/Temp/1525938559881.png)


#### test05.txt


![1525951182833](C:/Users/Boatman/AppData/Local/Temp/1525951182833.png)


![1525951260523](C:/Users/Boatman/AppData/Local/Temp/1525951260523.png)






#### test06.txt


![1525938780778](C:/Users/Boatman/AppData/Local/Temp/1525938780778.png)


![1525938792544](C:/Users/Boatman/AppData/Local/Temp/1525938792544.png)


#### test07.txt


![1525938919673](C:/Users/Boatman/AppData/Local/Temp/1525938919673.png)


![1525938978496](C:/Users/Boatman/AppData/Local/Temp/1525938978496.png)


#### test08.txt


![1525939048356](C:/Users/Boatman/AppData/Local/Temp/1525939048356.png)


![1525939062153](C:/Users/Boatman/AppData/Local/Temp/1525939062153.png)


#### test09.txt


![1525939148239](C:/Users/Boatman/AppData/Local/Temp/1525939148239.png)


![1525939165126](C:/Users/Boatman/AppData/Local/Temp/1525939165126.png)


#### test10.txt


![1525939254694](C:/Users/Boatman/AppData/Local/Temp/1525939254694.png)


![1525939266949](C:/Users/Boatman/AppData/Local/Temp/1525939266949.png)


## 软件设计


### 程序流程


```mermaid
graph TB
s1("开始")-->s2[输入待编译文件名]
s2-->|读文件|s3[词法分析器]
s3-->|合法记号|s4["语法分析器(递归下降的预测分析）"]
s4-->|取下一个记号|s3
s4-->s5["L属性定义的自上而下翻译"]
s5-->s6{"完成所有编译？"}
s6-->|否|s4
s6-->|是|s7[生成html文件]
s7-->s8(结束)
```


### 函数关系


#### 词法分析函数


##### 主要思想


对文本文件中读入的字符串，从第一个字符开始按照DFA进行匹配，返回每个记号对应的编号（syn）。


```
void scaner()
{


    cishu++;
    for(n=0;n<8;n++) token[n]=NULL;
    ch=prog[p++];
    while(ch==' ')
    {
        ch=prog[p];
        p++;
    }
    
    if(ch == '\\') {
    ch = prog[p++];
    m=1;
    token[0] = '\\';
    while(ch>='a'&&ch<='z') {
    token[m++]=ch;
            ch=prog[p++];
}
p--;
for(n=0;n<3;n++)  
            if(strcmp(token,rwtab[n])==0)
            {
                syn=n+1;
                return;
            }
}
    
    if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')) 
    {
        m=0;
        while((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
        {
            token[m++]=ch;
            ch=prog[p++];
        }
        token[m++]='\0';
        p--;
        syn=4;
    }
    else if((ch>='0'&&ch<='9')) 
    {
        {
            sum=0;
            while((ch>='0'&&ch<='9'))
            {
                sum=sum*10+ch-'0';
                ch=prog[p++];
            }
        }
        p--;
        syn=5;
        if(sum>32767)
            syn=-1;
    }
    else switch(ch)  
    {
        case '(':syn=7;token[0]=ch;break;
        case ')':syn=8;token[0]=ch;break;
        case '{':syn=9;token[0]=ch;break;
        case '}':syn=10;token[0]=ch;break;
        case '_':syn=11;token[0]=ch;break;
        case '^':syn=12;token[0]=ch;break;
        case '$':syn=13;token[0]=ch;break;
        case '\n':syn=-2;break;
        case '\0':syn=0;break;
        default: syn=-1;break;
    }
}
```


##### 运行截图


![1525941777480](C:/Users/Boatman/AppData/Local/Temp/1525941777480.png)






#### 语法分析函数


##### 主要思想


每从词法分析函数返回一个序号，便进行匹配，若与某一状态相符，则进入该状态，取下一个序号进行匹配，当完全匹配到某一产生式时，进行归约。


```
int match_B() {
while(syn != 13) 
{
if(syn == 4 || syn == 5)
{
if(syn == 4) printf("B -> id\n") ;
if(syn == 5) printf("B -> num\n");
scaner();
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
if(syn == 10 || syn == 13 || syn == 8) return true;  // B -> id/num + }/$
if(syn == 11) //B_
{
scaner();
if(syn == 12)      // B -> B_^
        {
        scaner();
        if(syn == 9)   // B_^{
        {
        scaner();
        if(match_B())  // B_^{B
        {
        //scaner();
        if(syn == 10)  //B_^{B}
        {
        scaner();
        if(syn == 9) {  //B_^{B}{
        scaner();
        if(match_B())  //B_^{B}{B
        {
        // scaner();
        if(syn == 10)  //B_^{B}{B}
        {
        printf("B -> B_^{B}{B} \n");
scaner() ;
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;  //B_^{B}{B} + }/)/$
}
}
}
}
}
}
}
else if(syn == 9)   // B -> B_{
{
scaner();
if(match_B())   // B -> B_{B
{
//scaner();
if(syn == 10) // B -> B_{B}
{
printf("B -> B_{B} \n");
scaner();
if(syn == 1 || syn == 2 || syn ==3 )printf("B -> BB\n") ;
if(syn == 13 || syn == 10 || syn == 8) return true;  // B -> B_{B} + }/)/$
}
}
}
}
else if(syn == 12)  // B -> B^
{
scaner();
if(syn == 9)    // B -> B^{
{
scaner();
if(match_B())  // B -> B^{B
{
//scaner();
if(syn == 10) // B -> B^{B}
{
printf("B -> B^{B} \n");
scaner();
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
if(syn == 13 || syn == 10 || syn == 8) return true;  // B -> B^{B} + }/)/$
}
}
}
}
// else {
// printf("B -> id \n");  // B -> ID
// scaner();
// if(syn == 13 || syn == 10) return true; // B -> ID + $/}
// }
}

    else if(syn == 2) {    // B -> /int
        scaner();
        if(syn == 9) {      // B -> /int{
        scaner();
        if(match_B()) {    // B -> /int{B
        //scaner();
        if(syn == 10) {   // B -> /int{B}
        scaner();
        if(syn == 9) {   // B -> /int{B}{
        scaner() ;
        if(match_B()) {     // B -> /int{B}{B
        //scaner();
        if(syn == 10) {    // B -> /int{B}{B}
        scaner();
        if(syn == 9) {    // B -> /int{B}{B}{
        scaner();
        if(match_B()){   // B -> /int{B}{B}{B
        if(syn != 10)
        scaner();  // B -> /int{B}{B}{B}
        if(syn == 10) {
       
        printf("B -> \\int{B}{B}{B} \n");
        scaner();
        if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;    // B -> /int{B}{B}{B} + }/)/$
        }
        }
        }
        }
        }
        }
        }
        }
        }
    }


    else if(syn == 3) {    // B -> /sum
        scaner();
        if(syn == 9) {      // B -> /sum{
        scaner();
        if(match_B()) {    // B -> /sum{B
        if(syn == 10) {   // B -> /sum{B}
        scaner();
        if(syn == 9) {   // B -> /sum{B}{
        scaner();
        if(match_B()) {     // B -> /sum{B}{B
        if(syn == 10) {    // B -> /sum{B}{B}
        scaner();
        if(syn == 9) {    // B -> /sum{B}{B}{
        scaner();
        if(match_B()){   // B -> /sum{B}{B}{B
        if(syn != 10)
        scaner();
        if(syn == 10) {     // B -> /sum{B}{B}{B}
        printf("B -> \\sum{B}{B}{B} \n");  
scaner();     
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10 || syn == 8) return true;    // B -> /sum{B}{B}{B} + }/)/$
        }
        }
        }
        }
        }
        }
        }
        }
    }
    }


    else if(syn == 5) {
        // scaner();
        printf("B -> num \n");  
scaner();     
if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10) return true;
       
    }


    else if(syn == 1) {
        //scaner();
        printf("B -> \\blank \n");
        scaner();
        if(syn == 1 || syn == 2 || syn ==3) printf("B -> BB\n") ;
        if(syn == 13 || syn == 10) return true;
    }


    else if(syn == 7) {     //B -> (
        scaner();
        if(match_B()) {     //B -> (B
        //scaner();
        if(syn == 8) {     //B -> (B)
        // scaner();
        printf("B -> (B)\n");
scaner();       
        return true;   //B -> (B) + $/}
        }
        else match_B();
        }       
    }
    else if(syn == -1) {
    return false;
}
 }
}
```


##### 运行截图


![1525942065526](C:/Users/Boatman/AppData/Local/Temp/1525942065526.png)


#### 关系


​ 语法分析函数是建立在词法分析函数之上的，在语法分析过程中，每次都要先运行词法分析函数，使用其返回值syn来进行语法分析。


### 接口定义


​ 用户只需在任意文本文件中输入代码，运行该程序，输入文本文件名即可编译。






## 体会与建议


​ 通过本次大作业，我深刻体会到了“编译”二字的真正含义，理解了编译器构造的一般原理和基本实现方法，特别是词法分析、语法分析和语法制导翻译三个阶段，同时还大大提高了编程能力。本次大作业让我知道一段源代码是通过哪些过程，使计算机能够读懂，并表达给前端用户。首先是词法分析，词法分析器把构成源程序的字符流翻译成记号流，还完成一些和用户接口的任务，是整个编译器框架的基石，有了词法分析器，编译器才能分辨出每个字符都属于哪一类，这是编译器进行“看懂”源程序的前提；拿到词法分析器的记号后，开始进行语法分析，我采用的是LL(1)文法来进行语法分析，因此需要注意消除左递归，语法分析能够让编译器“看懂”源程序；编译器“看懂”程序了，如何把程序翻译为用户能够看懂的形式呢？这就是语法制导翻译的作用。本次大作业通过使用html脚本语言，随着语法分析器的归约过程，使用L属性定义的自上而下翻译，将抽象难懂的源代码文本翻译为简洁直观的html文件，这就是该编译器的作用。


​ 虽然这个编译器只实现了一个很小的功能，但在这个实现过程中，我们可以理解那些大型的编程语言编译器和排版语言编译器的实现原理，能够以一个更底层的视角去了解一个编译器，这能改变我们的编程思维，提升编程能力，我觉得是这次大作业最重要的意义。


​ 没有想到什么实质性的建议，要是能够不限编程语言的或许可以有更多的编译器形式？比如做成一个网页端的数学公式排版语言。


​ 总之感谢老师和助教的帮助，这次大作业实实在在地提升了我非常薄弱的编程能力，让我具备了一些编程思维。
害羞的X
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
西安电子科技大学编译原理大作业
05-20
西安电子科技大学编译原理大作业，为简单的函数绘图语言编写一个解释器。该解释器接受用绘图语言编写的源程序，经过语法和语义分析后，直接将源程序所规定的图形显示在显示屏（或显示窗口）中。作业的目的是：通过自己动手编写解释器，掌握语言翻译，特别是语言识别的基本方法。
编译原理大作业 完整编译器
09-05
编译原理大作业 完整编译器 词法分析 语法分析 语义分析 简单绘图语言
【编译原理大作业】Tiny+的三地址码
Four's
08-11 2742
  咕得有点久了   这是编译原理大作业的第二步：进行语义分析，生成三地址码。   三地址码是一种平台无关的中间代码（类似汇编，但没到 x86、MIPS 那么具体），特点是：1、变量和 label 无需换成具体的地址，能区分清楚就行（例如嵌套作用域的同名变量要区分开）；2、寄存器无限量，不需要考虑有限的寄存器池；3、没有关于 CPU、操作系统的对接细节。这还是一个比较中间层次的东西，要生成具体的可执行代码时，不同平台可以直接拿三地址码来翻译。   有了上一步的语法树之后，这一部分就不需要额外的工具了，就在语
【编译原理】东北大学2022春季大作业之作业一【40%】编译一个TEX项目【已更新】【命令行编译】【texworks编译】【回答了一些问题】
不再痛苦的秘密，你找到了吗
04-17 2842
目录 前言 作业一【编译一个TEX项目】 1.开源网站 2.任务 3.作业完成流程 4.一点点小问题 前言： 【作业内容简介】 编译器不仅仅可以编译我们常用的C、C++、Java等程序开发语言，也可以处理各种文本编辑和排版类语言。Tex就是一类常见的文档排版系统，它所处理的对象一般也被称作Tex语言、Tex文本、Tex脚本等。比如，Letex、XeTex、XeLatex都是基于Tex的系统，被经常使用在科技文献的写作和排版中。包括，现在许多会议、...
中科大编译原理大作业PL/0
12-27
中科大郑启龙老师班编译原理大作业PL/0编译器拓展。1.在PL/0中允许有数组变量声明/对数组元素赋值/在表达式中引用数组元素等。2.为PL/0增加逻辑运算符&&、||和！。3.实现简单的引用变量。4. 参数传递。要求：（a）先...
中国传媒大学计算机网络空间安全学院编译原理作业答案
11-12
中国传媒大学计算机网络空间安全学院的编译原理作业答案涵盖了该学科的关键概念和技术，包括词法分析、语法分析、语义分析和代码生成等核心环节。 1. **词法分析**：这是编译的第一步，也称为扫描。它将源代码分解...
编译原理正则表达式转NFA转DFA DFA最小化 Cpp代码
09-17
编译原理课的大作业 包含三个小实验 在一个cpp文件里 正则表达式转换为nfa nfa转换为dfa dfa最小化 个人原创代码
中国海洋大学编译原理期末试题+重点+实验报告及代码+作业答案
最新发布
10-12
《编译原理知识详解》 编译原理是计算机科学领域中的一个重要分支，它研究如何将高级编程语言转换为机器可执行的低级指令。...因此，对于中国海洋大学的学生来说，理解和应用编译原理的知识至关重要。
编译原理大作业（递归下降法）
12-31
编译原理大作业，C语言小子集编译程序-递归下降分析。本上机实习是为C语言(子集)设计一个编译程序，完成词法分析、语法分析、语义分析等功能，并生成某种机器上的目标代码(汇编语言)或中间代码(四元式)。
西电编译原理大作业
05-14
这是西电编译原理上机的一些资料。关于制作一个数据库的。
中国科学技术大学编译原理实验指导
12-20
中国科学技术大学编译原理实验指导，PPT格式，好材料
编译原理大作业
12-28
编译原理大作业
编译原理基础习题与上机题答案（西电版）
03-27
《编译原理基础》习题与上机题答案，西安电子科技大学出版社
清华大学 清华编译原理
06-14
**清华大学编译原理课程** 清华大学的编译原理课程涵盖了上述所有核心概念，并可能深入到现代编译技术，如JIT编译、垃圾回收、并行编译、动态优化等方面。课程可能包含理论讲解、实例分析、实验项目和作业，以帮助...
中科大 编译原理 从零开始的编译原理（第三单元：词法分析（Part II） 正则转NFA + NFA转DFA + DFA最小化）
Love 6's Private Blog
11-18 807
文章目录前引第三单元：词法分析（Part II）1、任务介绍2、实现思路3、代码实现4、示例输入 + 实现效果结束语 前引 好久不见 自从上一篇写完了第二章作业后 我就没继续写了 哈哈哈 因为这一章的任务就是完成一个正则引擎要完成的所有的事情 如果之前看到过我完成的正则引擎的话 哈哈哈 这个作业还是挺难的 但是我把正则引擎搬过来处理这个实属有点犯规了 但是这些步骤如果都能一步步处理的话 连在一起就能完成一个正则引擎了 这里再贴一个我的正则引擎全流程完成的链接吧 从零开始自制实现正则引擎 全流程记录
编译原理：cminus_compiler-2021-fall Lab1
qq_45795586的博客
01-20 1677
说点什么 某湖的编译原理实验。这个实验其实原本是中科大他们那边的编译原理实验项目，然后我们的编译原理实验就是果果和他们py的（X） 注意：本博客仅供参考！！！ 0.基础知识 在本次实验中我们讲重点用到FLEX和以C-为基础改编的cminus-f语言。这里对其进行简单介绍。 0.1 cminus-f词法 C MINUS是C语言的一个子集，该语言的语法在《编译原理与实践》第九章附录中有详细的介绍。而cminus-f则是在C MINUS上追加了浮点操作。 1.关键字 else if int return void
西电编译原理实验-函数绘图语言解释器
球球的博客
12-20 1223
函数绘图语言解释器 硬编码DFA的词法分析器 递归下降算法构建语法分析器
西电编译原理大作业csdn
05-12
西安电子科技大学编译原理大作业是一项提高学生编程能力和理解编译原理的重要任务。该作业要求学生在一定时间内使用指定的编程语言构建一个编译器，将给定的源代码转换为目标代码。此外，学生还需要在代码转换的过程中实现语法分析和语义分析，以确保转换后的代码满足语法和语义规则。 该作业可以提高学生对编译器的理解和实践能力，同时也可以锻炼学生的编程能力和解决实际问题的能力。在完成该作业过程中,学生需要自行分析编译器工作流程，理解编译器中所需的数据结构和算法，并对编译器的性能进行优化。这样的经历也会有助于学生提高编程思维和逻辑能力、培养细心认真的态度、提高代码规范以及团队分工合作的意识。 总之，西安电子科技大学编译原理大作业csdn是一项非常实用的项目，对学生的编程能力提升和实践能力锻炼都具有非常重要的作用。通过这项作业，学生们不仅可以理论上学习编译原理知识，还可以在实践中获得更深刻的理解和体验。这有助于学生在未来的职业生涯中更好更快的适应工作需要。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值