首页 / JAVA / 编译原理大作业(用java编写小型GCC 编译器)

编译原理大作业(用java编写小型GCC 编译器)

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了编译原理大作业(用java编写小型GCC 编译器)，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9394字，纯文字阅读大概需要14分钟。

内容图文

以前只用编译器编译程序，现在学完编译原理这门课以后，通过编译大作业，我对编译器的工作原理有了比较清晰的认识
编译器的工作原理
编译器 (Compiler) 是一种将由一种语言编写的程序转换为另一种编程语言的可执行程序. 现代软件对于编译器的需求远甚从前, 究其原因很简单: 作为中间层, 编译器是构建更高层抽象的基础设施. 编译器意欲将人类可阅读的高阶代码, 翻译为机器能运行的低阶代码.
现代编译器的主要工作流程为: 源代码（source code）→ 预处理器（preprocessor）→ 编译器（compiler）→ 汇编程序（assembler）→ 目标代码（object code）→ 链接器（Linker）→ 可执行文件（executables）1.

其中, 编译器位于一个最重要的位置: 将源码转为汇编(上文提到的css, js也可认为是一种汇编).

词法分析

词法分析器根据词法规则识别出源程序中的各个记号（token），每个记号代表一类单词（lexeme）。源程序中常见的记号可以归为几大类：关键字、标识符、字面量和特殊符号。词法分析器的输入是源程序，输出是识别的记号流。词法分析器的任务是把源文件的字符流转换成记号流。本质上它查看连续的字符然后把它们识别为“单词”。

语法分析

语法分析器根据语法规则识别出记号流中的结构（短语、句子），并构造一棵能够正确反映该结构的语法树。

语义分析

语义分析器根据语义规则对语法树中的语法单元进行静态语义检查，如果类型检查和转换等，其目的在于保证语法正确的结构在语义上也是合法的。

中间代码生成

中间代码生成器根据语义分析器的输出生成中间代码。中间代码可以有若干种形式，它们的共同特征是与具体机器无关。最常用的一种中间代码是三地址码，它的一种实现方式是四元式。三地址码的优点是便于阅读、便于优化。

中间代码优化

优化是编译器的一个重要组成部分，由于编译器将源程序翻译成中间代码的工作是机械的、按固定模式进行的，因此，生成的中间代码往往在时间和空间上有很大浪费。当需要生成高效目标代码时，就必须进行优化。

目标代码生成

目标代码生成是编译器的最后一个阶段。在生成目标代码时要考虑以下几个问题：计算机的系统结构、指令系统、寄存器的分配以及内存的组织等。编译器生成的目标程序代码可以有多种形式：汇编语言、可重定位二进制代码、内存形式。

7 符号表管理

符号表的作用是记录源程序中符号的必要信息，并加以合理组织，从而在编译器的各个阶段能对它们进行快速、准确的查找和操作。符号表中的某些内容甚至要保留到程序的运行阶段。

8 出错处理

用户编写的源程序中往往会有一些错误，可分为静态错误和动态错误两类。所谓动态错误，是指源程序中的逻辑错误，它们发生在程序运行的时候，也被称作动态语义错误，如变量取值为零时作为除数，数组元素引用时下标出界等。静态错误又可分为语法错误和静态语义错误。语法错误是指有关语言结构上的错误，如单词拼写错、表达式中缺少操作数、begin和end不匹配等。静态语义错误是指分析源程序时可以发现的语言意义上的错误，如加法的两个操作数中一个是整型变量名，而另一个是数组名等。

编译大作业:
LL1文法:
1、文法开始：
S->void main(){A}
2、声明：
X->YZ;
Y->int|char|bool
Z->UZ’
Z’->,Z| $/*<![CDATA[*/ U->idU’ U’->=L| /*]]>*/$
3、赋值：
R->id=L;
4、算术运算：
L->TL’
L’->+L|-L| $/*<![CDATA[*/ T->FT’ T’->*T|/T| /*]]>*/$
F->(L)
F->id|num
O->++|–| $/*<![CDATA[*/ Q->idO| /*]]>*/$
5、布尔运算
E->HE’
E’->&&E| $/*<![CDATA[*/ H->GH’ H’->||H H’-> /*]]>*/$
G->FDF
D-><|>|==|!=
G->(E)
G->!E
5、控制语句
B->if (E){A}else{A}
B->while(E){A}
B->for(YZ;G;Q){A}
6、功能函数
B->printf(P);
B->scanf(id);
P->id|ch|num

7、复合语句
A->CA
C->X|B|R
A->$

1、构造LL1属性翻译文法
构造LL1属性翻译文法即在原有LL1文法基础上加上动作符号，并给非终结符和终结符加上一定属性，给动作符号加上语义子程序。对原有LL1文法改进的地方如下：
1、赋值：
产生式语义子程序

R->@ASS_R id =L@ EQ; @ASS{R.VAL=id并压入语义栈}
@EQ{RES=R.VAL,OP=’=’,ARG1=L.VAL,
new fourElement(OP,ARG1,/, RES)}
U->@ASS_UidU’ {U.VAL=id并压入语义栈}
U’->=L|$@EQ_U’ {RES=U.VAL,OP=’=’,ARG1=L.VAL,new fourElement(OP,ARG1,/, RES)}

2、算术运算：
产生式语义子程序

L->TL’@ADD_SUB {If(OP!=null) RES= NEWTEMP; L.VAL=RES,并压入语义栈;New fourElement(OP, T.VAL;,L’VAL, RES)，
}
L’->+L@ADD {OP=+,ARG2=L.VAL}
L’->-L@SUB {OP=-,ARG2=L.VAL}
L’->$
T->FT’@DIV_MUL { if (OP !=null) RES= NEWTEMP;T.VAL=RES;
new FourElement(OP,F.VAL,ARG2, RES)
else ARG1=F.VAL; }
T’->/T@DIV {OP=/,ARG2=T.VAL}
T’->T@MUL {OP=,ARG2=T.VAL}
T’-> $/*<![CDATA[*/ F->(L)@VOL {F.VAL->L.VAL} F->@ASS_F num|id {F.VAL=num|id} Q->idO| /*]]>*/$
O->@SINGLE_OP++|– {OP=++|–}

3、布尔运算
产生式语义子程序

G->FDF@COMPARE{OP=D.VAL;ARG1=F(1).VAL;ARG2=F(2).VAL,RES=NEWTEMP;
New fourElement(OP,F.VAL,ARG2, RES );G.VAL=RES并压入语义栈}
D->@COMPARE_OP<|>|==|!={D.VAL=<|>|==|!=,并压入语栈}

4、控制语句
产生式语义子程序
B->if (G)@IF_FJ{A}@IF_BACKPATCH_FJ @IF_RJ else{A}@IF_BACKPATCH_RJ
@IF_FJ{OP=”FJ”;ARG1=G.VAL;RES=if_fj, New fourElement(OP,ARG1,/, RES ),将其插入到四元式列表中第i个}
@IF_BACKPATCH_FJ{回填前面假出口跳转四元式的跳转序号, BACKPATCH (i,if_fj)}
B->while(G)@WHILE_FJ{A}@WHILE_RJ@WHILE_BACKPATCH_FJ {参照if else}
B->for(YZ;G@FOR_FJ;Q){A@SINGLE}@FOR_RJ@FOR_BACKPATCH_FJ {参照if else }
@SINGLE {ARG1=id;RES=NEWTEMP;New fourElement(OP,ARG1,/,RES)}

说明：
（1）、R.VAL表示符号R的值，VAL是R的一个属性，其它类似。
（2）、NEWTEMP()函数：每调用一次生成一个临时变量，依次为T1，T2，…Tn。
（3）、BACKPATCH (int i,int res):回填函数，用res回填第i个四元式的跳转地址。
（4）、new fourElement（String OP,String ARG1,String ARG2,String RES ）:生成一个四元式
（OP,ARG1,ARG2,RES）

技术分享

主界面代码

            
                package gui;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

import javax.swing.*;
import compiler.*;

publicclassMainFrameextendsJFrame {

    TextArea sourseFile;//用来显示源文件的文本框
    String soursePath;// 源文件路径
    String LL1Path;
    String wordListPath;
    String fourElementPath;
    LexAnalyse lexAnalyse;

    Parser parser;
    publicMainFrame() {
        this.init();
    }

    publicvoidinit() {

        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Dimension screen = toolkit.getScreenSize();
        setTitle("向贤章C语言小型编译器");
        setSize(750, 480);
        super.setResizable(false);
        super.setLocation(screen.width / 2 - this.getWidth() / 2, screen.height
                / 2 - this.getHeight() / 2);
        this.setContentPane(this.createContentPane());
    }

    private JPanel createContentPane() {
        JPanel p = new JPanel(new BorderLayout());
        p.add(BorderLayout.NORTH, createUpPane());
        p.add(BorderLayout.CENTER, createcCenterPane());
        p.add(BorderLayout.SOUTH, creatBottomPane());
        // p.setBorder(new EmptyBorder(8,8,8,8));return p;
    }

    private Component createUpPane() {
        JPanel p = new JPanel(new FlowLayout());
        final FilePanel fp = new FilePanel("选择待分析文件");
        //final FilePanel fp1 = new FilePanel("xiang");
        JButton button = new JButton("确定");
        button.addActionListener(new ActionListener() {

            @OverridepublicvoidactionPerformed(ActionEvent e) {
                String text;
                try {
                    soursePath = fp.getFileName();
                    text = readFile(soursePath);
                    sourseFile.setText(text);

                } catch (IOException e1) {
                    e1.printStackTrace();
                }            

            }
        });
        p.add(fp);
        //p.add(fp1);
        p.add(button);
        return p;
    }

    private Component createcCenterPane() {
        JPanel p = new JPanel(new BorderLayout());
        JLabel label = new JLabel("源文件如下：");
        sourseFile = new TextArea();
        sourseFile.setText("");
        p.add(BorderLayout.NORTH, label);
        p.add(BorderLayout.CENTER, sourseFile);
        return p;
    }

    private Component creatBottomPane() {
        JPanel p = new JPanel(new FlowLayout());
        JButton bt1 = new JButton("词法分析");
        JButton bt2 = new JButton("语法分析");
        JButton bt4 = new JButton("中间代码生成");
        JButton bt5 = new JButton("目标代码生成");
        bt1.addActionListener(new ActionListener() {

            @OverridepublicvoidactionPerformed(ActionEvent e) {
                try {
                    lexAnalyse=new LexAnalyse(sourseFile.getText());
                    wordListPath = lexAnalyse.outputWordList();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                InfoFrame inf = new InfoFrame("词法分析", wordListPath);

                inf.setVisible(true);
            }
        });
        bt2.addActionListener(new ActionListener() {

            @OverridepublicvoidactionPerformed(ActionEvent e) {
            lexAnalyse=new LexAnalyse(sourseFile.getText());
            parser=new Parser(lexAnalyse);
                try {
                    parser.grammerAnalyse();
                    LL1Path= parser.outputLL1();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                InfoFrame inf = new InfoFrame("语法分析", LL1Path);
                inf.setVisible(true);
            }
        });

        bt4.addActionListener(new ActionListener() {

            @OverridepublicvoidactionPerformed(ActionEvent e) {
                try {
                    lexAnalyse=new LexAnalyse(sourseFile.getText());
                    parser=new Parser(lexAnalyse);
                    parser.grammerAnalyse();
                    fourElementPath=parser.outputFourElem();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                InfoFrame inf = new InfoFrame("中间代码生成", fourElementPath);
                inf.setVisible(true);
            }
        });
        bt5.addActionListener(new ActionListener() {

            @OverridepublicvoidactionPerformed(ActionEvent e) {
                try {
                    lexAnalyse=new LexAnalyse(sourseFile.getText());
                    parser=new Parser(lexAnalyse);
                    parser.grammerAnalyse();
                    fourElementPath=parser.outputFourElem();
                } catch (IOException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
                huibian inf = new huibian("目标代码生成", fourElementPath);
                inf.setVisible(true);
            }
        });

        p.add(bt1);
        p.add(bt2);
        //p.add(bt3);
        p.add(bt4);
        p.add(bt5);
        return p;
    }

    publicstatic String readFile(String fileName) throws IOException {
        StringBuilder sbr = new StringBuilder();
        String str;
        FileInputStream fis = new FileInputStream(fileName);
        BufferedInputStream bis = new BufferedInputStream(fis);
        InputStreamReader isr = new InputStreamReader(bis, "UTF-8");
        BufferedReader in = new BufferedReader(isr);
        while ((str = in.readLine()) != null) {
            sbr.append(str).append(‘\n‘);
        }
        in.close();
        return sbr.toString();
    }

    publicstaticvoidmain(String[] args) {
        // TODO Auto-generated method stub
        MainFrame mf = new MainFrame();
        //TinyCompiler tinyCompiler = new TinyCompiler();//mf.tinyCompiler = tinyCompiler;
        mf.setVisible(true);
    }
}

class FilePanel extends JPanel {
    FilePanel(String str) {
        JLabel label = new JLabel(str);
        JTextField fileText = new JTextField(35);
        JButton chooseButton = new JButton("浏览...");
        this.add(label);
        this.add(fileText);
        this.add(chooseButton);
        clickAction ca = new clickAction(this);
        chooseButton.addActionListener(ca);
    }

    public String getFileName() {
        JTextField jtf = (JTextField) this.getComponent(1);
        return jtf.getText();    
    }

    // 按钮响应函数privateclassclickActionimplementsActionListener {private Component cmpt;

        clickAction(Component c) {
            cmpt = c;
        }

        publicvoidactionPerformed(ActionEvent event) {
            JFileChooser chooser = new JFileChooser();
            chooser.setCurrentDirectory(new File("."));
            int ret = chooser.showOpenDialog(cmpt);
            if (ret == JFileChooser.APPROVE_OPTION) {
                JPanel jp = (JPanel) cmpt;
                JTextField jtf = (JTextField) jp.getComponent(1);//获取zujian
                jtf.setText(chooser.getSelectedFile().getPath());
            }
        }
    }
}

词法分析:
技术分享
语法分析

中间代码生成

目标代码生成

原文：http://blog.csdn.net/u013445530/article/details/46671837

内容总结

以上是互联网集市为您收集整理的编译原理大作业(用java编写小型GCC 编译器)全部内容，希望文章能够帮你解决编译原理大作业(用java编写小型GCC 编译器)所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1054536.html

来源：【匿名】

【上一篇】java-thread 【下一篇】JAVA/JSP学习系列之五

更多 ►

【编译原理大作业(用java编写小型GCC 编译器)】教程文章相关的互联网学习教程文章

Null作为参数的时候，Java编译器如何调用函数？【代码】【图】

1publicclass TestNull {2publicvoid method(Object o){3 System.out.println("Object Version");4 }5 6publicvoid method(String s){7 System.out.println("String Version");8 }910publicstaticvoid main(String[] args) { 11 TestNull tn= new TestNull(); 12 tn.method(null); 13 } 1415 }　　　编译可以通过，运行结果如下：　　那么，Null作为参数的时候究竟如何调用函数？回答这个...

(原)java 向上转型中，任何域的访问操作都是由编译器解析，不是多态【代码】

最近在向java发力，学习学习了下。看到了多态这一节，书中有个比较好的例子，所以就准备写下来，记录下来： 1package dynamic_binding01;2 3publicclass dynamic_binding01 {4 5publicstaticvoid main(String[] args) {6// TODO Auto-generated method stub 7Super super1=new Sub();8 System.out.println("sup.field="+super1.field+",sup.getField="+super1.getField());9Sub sub=new Sub(); 10 System.out.prin...

编译原理实战入门：用 JavaScript 写一个简单的四则运算编译器（四）结语

四则运算编译器，虽然说功能很简单，只能编译四则运算表达式。但是编译原理前端部分几乎都有涉及，词法分析，语法分析，还有代码生成。再复杂的编译器、再简单的编译器，功能上是差不多的，只是复杂的编译器实现上会更困难。这个系列的文章是为了帮助你入门，在这个基础上再去看编译原理相关书籍，不至于打瞌睡。如果你对编译原理很有兴趣，并且想更深一步的学习，在这里强烈推荐你看一本书——我心目中的神书——《计算机系统要素...

Java虚拟机即时编译器技术JIT

Java虚拟机中有许多附加技术用以提升速度，尤其是与加载器操作相关的，被称为“即时”(Just-In-Time，JIT)编译器的技术。这种技术可以把程序全部或部分翻译成本地机器码(这本来是JVM的工作)，程序运行速度因此得以提升。当需要装载某个类时，编译器会先找到其.class文件，然后将该类的字节码装入内存。此时，有两种方案可供选择： (1)一种就是让即时编译器编译所有代码。但这种做法有两个缺陷：这种加载动作散落在整个程序生命周期...

实现把C语言编译成java字节码的编译器一个将C语言编译成java字节码的实例【图】

原文：https://www.cnblogs.com/ZHONGZHENHUA/p/10125638.html

Java-idea编译器的个人配置-1-注释配置【代码】

一、注释的配置。1、类注释：在File | Settings | Editor | File and Code Templates的设置下找到Includes点击+添加一个配置名称为FileHead，在方框中填入一下参数：/** * Description: ${description} // 类说明 * @ClassName: ${NAME} // 类名，会自动填充 * @Author: GD // 创建者 * @Date: ${DATE} ${TIME} // 时间 * @Version: 1.0 // 版本 */然后在点击Files在里面找到Class，然后选中填入如...

Java-JVM_01_前端编译器【代码】【图】

1．编译器1.1．编译期分类一个*.java文件总体要经过编译期和运行期，会涉及到两类编译期：①编译期编译：一般表示*.java->*.class（包含字节码）的过程 — 也叫前端编译。②运行期编译：一般表示*.class->机器码的过程 — 也叫后端编译。1.2．编译器分类■前端编译器 ●作用：把*.java->*.class，以供加载器进行类型加载，并在在编译期优化程序编码。 ●种类：Sun的Javac、Eclipse的JDT。■后端编译器（JIT编译器） ●作用：把*...

java反编译器

一时手残，把java工程中的源文件给删了，幸亏还有.class文件，想起java可以反编译，所以试一试。JD-Eclipse如果是使用Eclipse的话，可以用Eclipse插件JadClipse，JadClipse提供一个class文件查看器可以直接打开class文件查看其反编译后的源代码。但是我没有找到win10版本,所以下载了jad158e.linux.intel，在wsl环境下运行，提示没有找到jad命令。JD-CoreJD-Core支持Java 5的新特性，如enum等，而且它提供独立的GUI程序JD-GUI和基于...

class 文件反编译器的 java 实现【代码】

最近由于公司项目需要，了解了很多关于类加载方面的知识，给项目带来了一些热部署方面的突破。由于最近手头工作不太忙，同时驱于对更底层知识的好奇与渴求，因此决定学习了一下 class 文件结构，并通过一周的不懈努力，已经掌握了class 的文件结构，并用 java 实现了一个简单的反编译器：读取 class 文件，反编译成纯 java 代码。下面来看一下具体的实现思路和代码分析。1. class 文件是一种平台无关性的二进制文件，通过 IO 流可...