基于Android的编译原理课程设计：C语言的预处理程序

已于 2022-07-07 09:30:37 修改
阅读量6.3w 收藏 14
点赞数 4
分类专栏： 计算机原理 课程设计 文章标签： 表达式文法 编译原理课设 算符优先分析 逆波兰式 安卓界面
于 2021-01-11 20:51:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cyril_KI/article/details/112486611
版权

目录

1. 题目要求

设计一个 C 语言的预处理程序，将C语言中所有的宏常量进行计算，并生成另外一个文件，将宏常量展开和计算的结果全部显示出来，最后将定义的宏在源程序中全部进行替换。
在这里插入图片描述

例如，源程序为：

#include <stdio.h>
#define  ADDR_START   0x20480000
#define  ADDR_A        ADDR_START + 0x04
#define  ADDR_B        ADDR_START + 15
#define  BUFFER_SIZE  1024
#define  BUFFER_END    ADDR_START + BUFFER_SIZE – 1
#define  PI      3.14
void main()
{
	float r, l;
	scanf(“%f”, &r);
	l = 2 * PI *r;
	memset(ADDR_START, BUFFER_SIZE, 0x00);
}

替换后为：

#include <stdio.h>
#define  ADDR_START   0x20480000
#define  ADDR_A        0x20480004
#define  ADDR_B        0x2048000F
#define  BUFFER_SIZE  1024
#define  BUFFER_END   0x204803FF
#define  PI      3.14
void main()
{
	float r, l;
	scanf(“%f”, &r);
	l = 2 * 3.14 *r;
	memset(0x20480000, 1024, 0x00);
}

2.思路分析

2.1文法设计

  我们知道，C 语言中运算符的优先级为：[] > (! ~) > (* / %) > (+ -) > (<< >>) > (> >= < <=) > (== !=) > & > ^ > | > && > || > ?: > (= += -= /= *= %=) > ,(逗号)。
  为保证依据设计的文法求得的算符优先矩阵符合上述要求，根据求算符优先矩阵的方法，从优先级别最低的逗号开始逐次往高级别推导，这样算出来的算符优先矩阵就是符合预期的。
  比如& < = = == ==，则文法设计为 G->G&H，G->H，H->H==I。可以看到 FirstVt(G) = {&, = = == ==}，FirstVt(H) = { = = == ==}，而 G->G&H，所以& < FirstVt(H)，即& < ==。同理根据 LastVt 可得 == > &。
  表达式文法设计过程中有以下几点值得考虑：

  1. 推至结尾 O 时，为了将前后连贯起来，O 必须能导出最开始的符号 A，同时若 A 是表达式，(A)也必然是表达式，于是最后两条产生式为 O->i，O->(A)，文法中用 i 表征一切变量。
  2. 下标运算符[]的设计。下标运算符在 C 语言中通常与数组结合起来，其标准用法为 a[i]，其中 a 为数组名，i 为下标。在上述所有双目运算符中，其产生式都是类似于 A->A&&B 这种形式，于是将[]运算符的产生式设计为：N->N[]O，其中 N 为数组名，O 为数组下标。
  3. 有了以上前提，在词法分析阶段，要将源程序中所有含有条件运算符以及下标运算符的表达式改写成上述产生式形式。
  4. 经过设计，最终文法为：
    在这里插入图片描述

2.2表达式的计算

  本次课设表达式的计算思路为：将原表达式转为逆波兰式，再进行计算，不使用属性文法计算。

2.3概要设计

  事先写好三个待分析的源程序文件，点击 Open 按钮，可选择打开哪一个源程序，打开后，会马上进行词法分析，得到各种有意义字符串的种别号，然后根据种别号对源程序设置不同的颜色，例如大小括号为红色，define 以及 include 为粉红色等等（参考了 VS CODE 的CPP 程序界面）。
  接下来点击 Lexical 按钮，开始进行词法分析。词法分析实际上在源程序打开后就已经结束了，点击 Lexical 按钮只是做一个展示功能。
  词法分析程序的主要任务是对构成源程序的字符串从左到右扫描，逐个字符地读入源程序字符并按照构词规则切分成一个一个具有独立意义的单词。并确定其属性（如关键字、宏常量、标识符等）。
  词法分析中将单词分为以下几类：

  1. 关键字 keyWord：由程序语言定义的具有固定意义的标识符，也称为保留字或基本字。
    如 auto、short、typedef 等
  2. 宏常量 MACRO：本次实验的主要目的就是分析宏常量，所以单独定义。
  3. 一般变量 var：用来表示程序中各种名字的字符串。
  4. 常数 number：常数的类型一般有整型、实型、布尔型、文字型。
  5. 运算符 ope：如+、－ 、*、/ 等。
  6. 界限符：如逗号、分号、括号等。
  7. 特殊字符 special：C 语言在语法上并未将 main、include 以及 define 等符号定义为关键字，单独列出。

  词法分析得到的结果是一个初始符号表，每一个表项都是一个向量，每一个向量表示一个有意义的字符串，比如(SIZE, MACRO, X + Y)，表明 SIZE 是一个宏常量，其表达式为 X +Y。又如(+, 4)表明加法运算符的种别号为 4。
  接下来点击 Grammar 按钮，即可进行语法分析。语法分析首先分析的是宏常量的表达式，
根据词法分析得到的符号表，找到每一个宏常量的表达式（可以是一个常数，也可以是一个很复杂的表达式），然后将每个表达式中的变量以及常数都用小写字母 i 替代，因为设计的文法当中默认用 i 表示操作数。例如 SIZE + X / Y 变为 i+i/i，然后用算符优先文法来规约这个表达式，并判断是否合法。
  宏常量的表达式语法分析完毕后，紧接着分析主函数当中的表达式，对于主函数中的表达式，与宏常量表达式一样，也将除开运算符以外的所有变量用 i 表示，然后用上述定义的表达式文法进行规约分析。分析完毕后，所有的分析过程在点击 Grammar 按钮的一瞬间都会显示在模拟器界面上。
  语法分析结束后，最后进行的是表达式计算。点击 Calculate 按钮，即可对所有经过语法分析并且合法的表达式进行计算。计算时首先将表达式转成逆波兰式，然后利用栈对其进行计算。每计算完一个表达式，就将符号表进行更新，方便下一步的计算，所有表达式的计算过程会显示在模拟器界面上。
  表达式计算完毕之后，开始对源程序进行替换，替换过程与计算过程同步进行。扫描源程序，对宏常量以及相关表达式出现的地方，用计算得到的值进行替换，该值通过扫描符号表得到。替换完毕后，再根据结果变换程序字符串的颜色，显示在模拟器界面上。

3.系统的类图

系统中包含一个主界面 MainActivity 以及五个子类，分别介绍如下：

  1. 主界面 MainActivity：主界面中包含两个 EditText 以及一个 RadioGroup，RadioGroup 中包含四个 RadioButton，分别对应打开文件、词法分析、语法分析以及表达式计算。
  2. Grammatical_Analysis 类：该类中定义了识别数字以及标识符的文法，其方法 booleanisVar(String x)与 boolean isNum(string x)分别来判断字符串是否是合法的标识符或者数字。
  3. Lexical_Analysis 类：词法分析类，该类中定义了所有可能出现的符号以及它们的类别号，并对源程序进行扫描，生成初始符号表。
  4. Operator_Precedence 类：算符优先分析类，该类中定义了表达式文法。findFirstVt()与findLastVt()用于求解所有非终结符的 FirstVt 以及 LastVt 集合； findRe()根据两个集合建立算符优先矩阵；check(String x)对表达式 x 进行算符优先分析，并给出规约结果。其余还有一些方法都是为了配合以上几个方法而设计。
  5. Compute 类：计算类，根据 Operator_Precedence 类的分析结果，对表达式进行计算。其中：mid2suffix()方法将给出的表达式转成逆波兰式；hex2dec()将计算过程中可能出现的十六进制数转成十进制数；calculateSuffix()用于计算 mid2suffix()产生的逆波兰式。
    类图如下：
    在这里插入图片描述

4.界面设计

4.1主界面

在这里插入图片描述

4.2打开文件

在这里插入图片描述

4.3词法分析

点击词法分析后，编辑器上缩，下方的显示栏显示词法分析结果，如下所示：
在这里插入图片描述

4.4语法分析

点击语法分析按钮，可对源程序中所有表达式进行语法分析，如下所示：
在这里插入图片描述

4.5表达式计算

点击表达式计算按钮，可将计算过程显示出来。另外可以看到，计算结果已经在源程序中替换。
在这里插入图片描述

5.部分源码

5.1界面MainActivity

package com.example.compiler;

import androidx.appcompat.app.AppCompatActivity;
import android.graphics.Color;
import android.os.Bundle;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.style.ForegroundColorSpan;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;
import android.widget.PopupWindow;
import android.widget.RadioButton;
import android.widget.RadioGroup;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.example.compiler.Utils.CheckAllExpression;
import com.example.compiler.Utils.Compute;
import com.example.compiler.Utils.Lexical_Analysis;

import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Map;
import java.util.Vector;

public class MainActivity extends AppCompatActivity {

    private RadioGroup rg_tab_bar;
    private RadioButton rb_open;
    private RadioButton rb_lexer;
    private RadioButton rb_grammar;
    private RadioButton rb_calculate;
    private View div;
    private EditText editText;
    private EditText editTextComp;
    private Lexical_Analysis lexical_analysis;
    private PopupWindow popupWindow;
    public String resourceString = "";   //源程序
    public String tab = "";
    public Vector<Vector> resVectors = new Vector<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        bindViews();
        rg_tab_bar.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
            @Override
            public void onCheckedChanged(RadioGroup group, int checkedId) {
                switch (checkedId) {
                    case R.id.rb_open:
                        rb_open.setOnClickListener(new View.OnClickListener() {
                            @Override
                            public void onClick(View v) {
                                View view=getLayoutInflater().inflate(R.layout.layout_pop,null);
                                TextView textView1 = view.findViewById(R.id.s1);
                                textView1.setOnClickListener(new View.OnClickListener() {
                                    @Override
                                    public void onClick(View v) {
                                        popupWindow.dismiss();
                                        resourceString = getResources().getString(R.string.source_1);
                                        //lexical_analysis.show();
                                        SpannableStringBuilder builder = convert(resourceString);
                                        editText.setText(builder);
                                    }
                                });
                                TextView textView2 = view.findViewById(R.id.s2);
                                textView2.setOnClickListener(new View.OnClickListener() {
                                    @Override
                                    public void onClick(View v) {
                                        popupWindow.dismiss();
                                        resourceString = getResources().getString(R.string.source_2);
                                        //lexical_analysis.show();
                                        SpannableStringBuilder builder = convert(resourceString);
                                        editText.setText(builder);
                                    }
                                });
                                TextView textView3 = view.findViewById(R.id.s3);
                                textView3.setOnClickListener(new View.OnClickListener() {
                                    @Override
                                    public void onClick(View v) {
                                        popupWindow.dismiss();
                                        resourceString = getResources().getString(R.string.source_3);
                                        SpannableStringBuilder builder = convert(resourceString);
                                        editText.setText(builder);
                                    }
                                });
                                popupWindow=new PopupWindow(view, rb_open.getWidth(), ViewGroup.LayoutParams.WRAP_CONTENT);
                                popupWindow.setOutsideTouchable(true);
                                popupWindow.setFocusable(true);
                                popupWindow.showAsDropDown(rb_open);
                            }
                        });
                        break;
                    case R.id.rb_lexer:    //词法分析
                        Lexical();
                        break;
                    case R.id.rb_grammar:    //语法分析每一个跟宏有关的式子是否是合法的
                        Grammar();
                        break;
                    case R.id.rb_calculate:    //计算并替换所有表达式
                        try {
                            Calculate();
                        } catch (FileNotFoundException e) {
                            e.printStackTrace();
                        }
                        break;
                }
            }
        });
    }

    private void bindViews() {
        tab = getResources().getString(R.string.tab);
        rg_tab_bar =  findViewById(R.id.rg_tab_bar);
        rb_open =  findViewById(R.id.rb_open);
        rb_lexer =  findViewById(R.id.rb_lexer);
        rb_grammar =  findViewById(R.id.rb_grammar);
        rb_calculate =  findViewById(R.id.rb_calculate);
        div = findViewById(R.id.div_tab_bar);
        editText = findViewById(R.id.edit);
        editTextComp = findViewById(R.id.comp);
    }

    private SpannableStringBuilder convert(String x) {
        String yy = getResources().getString(R.string.source_1);
        String []yyStrings = x.split("\n");
        for(int i = 0; i < yyStrings.length; i++) {
            if(yyStrings[i].contains("main")) {
                break;
            }
            else {
                yyStrings[i] = yyStrings[i].trim();
            }
        }
        x = "";
        for(int i = 0; i <yyStrings.length; i++) {
            x += (yyStrings[i] + "\n");
        }
        lexical_analysis = new Lexical_Analysis(yy);
        lexical_analysis.initNum();
        lexical_analysis.mainFunc();
        SpannableStringBuilder builder = new SpannableStringBuilder(x);
        for(int i = 0; i < x.length(); i++) {
            char y = x.charAt(i);
            if (y == '{' || y == '}' || y == '(' || y == ')') {
                builder.setSpan(new ForegroundColorSpan(Color.RED), i, i + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);//指定索引a到b-1的字符
            }
            if (y == '#' && x.charAt(i + 1) == 'i') {
                builder.setSpan(new ForegroundColorSpan(Color.rgb(204, 51, 204)), i, i + 8, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);//指定索引a到b-1的字符
                int j = i + 8;
                while (x.charAt(i) != '>') {
                    i++;
                }
                builder.setSpan(new ForegroundColorSpan(Color.rgb(153, 102, 113)), j + 1, i, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
            if (y == '#' && x.charAt(i + 1) == 'd') {
                builder.setSpan(new ForegroundColorSpan(Color.rgb(204, 51, 204)), i, i + 7, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

            }
        }
        for(String xString : lexical_analysis.keyWord) {
            int index = 0;
            while(index != -1) {
                index = x.indexOf(xString, index + xString.length());
                if(index != -1) {
                    builder.setSpan(new ForegroundColorSpan(Color.rgb(26, 107, 230)), index, index + xString.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                }
            }
        }
        for(String xString : lexical_analysis.keyWord) {
            int index = 0;
            while(index != -1) {
                index = x.indexOf(xString, index + xString.length());
                if(index != -1) {
                    builder.setSpan(new ForegroundColorSpan(Color.rgb(26, 107, 230)), index, index + xString.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                }
            }
        }
        int index1 = x.indexOf("main");
        builder.setSpan(new ForegroundColorSpan(Color.rgb(213, 213, 43)), index1, index1 + 4, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
        for(String xString : lexical_analysis.function) {
            int index = x.indexOf(xString);
            if(index != -1) {
                builder.setSpan(new ForegroundColorSpan(Color.rgb(213, 213, 43)), index, index + xString.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
        }
        //宏常量
        ArrayList<String> temp = new ArrayList<>();
        for(Vector<String> vector : lexical_analysis.resVector) {
            if(vector.get(1).equals("MACRO")) {
                temp.add(vector.get(0));
            }
        }
        System.out.println("temp = " + temp.size());
        for(String xString : temp) {
            int index = 0 - xString.length();
            while(index != -1) {
                index = x.indexOf(xString, index + xString.length());
                if(index != -1) {
                    builder.setSpan(new ForegroundColorSpan(Color.rgb(26, 107, 230)), index, index + xString.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
                }
            }
        }
        return builder;
    }

    //词法分析
    private void Lexical() {
        lexical_analysis = new Lexical_Analysis(resourceString);
        lexical_analysis.initNum();
        lexical_analysis.mainFunc();
        String finalString = "";
        for(Vector vector : lexical_analysis.resVector) {
            //System.out.print("(");
            String temp = "(";
            for(int j = 0; j < vector.size() - 1; j++) {
                //System.out.print(vector.get(j) + "," + " ");
                temp += (vector.get(j) + "," + " ");
            }
            //System.out.println(vector.get(vector.size() - 1) + ")");
            temp += (vector.get(vector.size() - 1) + ")" + "\n");
            finalString += temp;
        }
        RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) editText.getLayoutParams();
        lp.height = 500;
        editText.setLayoutParams(lp);
        RelativeLayout.LayoutParams lp1 = (RelativeLayout.LayoutParams) editTextComp.getLayoutParams();
        lp1.height = 2000;
        editTextComp.setLayoutParams(lp1);
        finalString = "词法分析结果为:" + "\n" + finalString;
        SpannableStringBuilder builder1 = new SpannableStringBuilder(finalString);
        builder1.setSpan(new ForegroundColorSpan(Color.RED), 0, 8, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);//指定索引a到b-1的字符
        editTextComp.setText(builder1);
    }
    //语法分析
    private void Grammar() {
        CheckAllExpression checkAllExpression = new CheckAllExpression(resourceString, tab);
        checkAllExpression.checkMacro();
        checkAllExpression.checkMain();
        RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) editText.getLayoutParams();
        lp.height = 500;
        editText.setLayoutParams(lp);
        RelativeLayout.LayoutParams lp1 = (RelativeLayout.LayoutParams) editTextComp.getLayoutParams();
        lp1.height = 1800;
        editTextComp.setLayoutParams(lp1);
        String finalString = checkAllExpression.resString;
        finalString = "语法分析结果为:" + "\n" + finalString;
        SpannableStringBuilder builder1 = new SpannableStringBuilder(finalString);
        builder1.setSpan(new ForegroundColorSpan(Color.RED), 0, 8, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);//指定索引a到b-1的字符
        editTextComp.setText(builder1);
    }

    private void Calculate() throws FileNotFoundException {
        lexical_analysis = new Lexical_Analysis(resourceString);
        lexical_analysis.initNum();
        lexical_analysis.mainFunc();
        resVectors = lexical_analysis.resVector;
        String showProcess = "";
        CheckAllExpression checkAllExpression = new CheckAllExpression(resourceString, "");
        checkAllExpression.checkMacro();
        checkAllExpression.checkMain();

        Map<String, String> expMap = checkAllExpression.expMap;  //存储表达式
        for(Map.Entry<String, String> entry : expMap.entrySet()) {
            String keyString = entry.getKey();
            String valueString = entry.getValue();
            //System.out.println(keyString + ":" + valueString);
            if(!keyString.equals("mainExp")) {
                String waitString = valueString.replace(" ", "");
                showProcess += ("正在计算的宏常量：" + keyString + "\n");
                showProcess += ("宏常量表达式：" + valueString + "\n");
                System.out.println("正在计算的宏常量：" + keyString);
                System.out.println("宏常量表达式：" + valueString);
                //System.out.println(waitString);
                waitString = Compute.hex2dec(waitString);
                //System.out.println(waitString);
                Compute compute = new Compute(waitString, resourceString);
                compute.lexical_Analysis.resVector = resVectors;
                String suffixString = compute.mid2suffix();
                showProcess += ("逆波兰式：" + suffixString + "\n");
                System.out.println("逆波兰式：" + suffixString);
                //System.out.println("suffix:" + suffixString);
                String resString = compute.calculateSuffix(suffixString);
                showProcess += compute.processString;
                showProcess += ("计算结果：" + resString + "\n" + "\n");
                System.out.println("计算结果：" + resString);
                System.out.println();
                for(int i = 0; i < resVectors.size(); i++) {
                    Vector<String> vector = resVectors.get(i);
                    if(vector.get(0).equals(keyString)) {
                        //System.out.println("当前被替换的宏常量为:" + keyString + " " + resString);
                        resVectors.get(i).set(2, resString);
                    }else {
                        continue;
                    }
                }
            }
        }

        //计算主函数中表达式
        System.out.println("计算主函数中表达式:");
        ArrayList<String> mainExpArrayList = checkAllExpression.mainExpArrayList;
        for(String valueString : mainExpArrayList) {
            if(valueString.contains("PI")) {
                continue;
            }
            String waitString = valueString.replace(" ", "");
            showProcess += ("正在计算的表达式：" + valueString + "\n");
            System.out.println("正在计算的表达式：" + valueString);
            //System.out.println(waitString);
            waitString = Compute.hex2dec(waitString);
            //System.out.println(waitString);
            Compute compute = new Compute(waitString, resourceString);
            compute.lexical_Analysis.resVector = resVectors;
            String suffixString = compute.mid2suffix();
            showProcess += ("逆波兰式：" + suffixString);
            System.out.println("逆波兰式：" + suffixString);
            //System.out.println("suffix:" + suffixString);
            String resString = compute.calculateSuffix(suffixString);
            showProcess += ("计算结果：" + resString + "\n" + "\n");
            System.out.println("计算结果：" + resString);
            System.out.println();
            for(int i = 0; i < resVectors.size(); i++) {
                Vector<String> vector = resVectors.get(i);
                if(waitString.contains(vector.get(0)) && vector.get(1).equals("var") || waitString.contains(vector.get(0)) && vector.get(1).equals("const")) {
                    //先找到resString中的答案
                    int index = resString.indexOf('=');
                    String real = resString.substring(index + 2, resString.length());
                    resVectors.get(i).add(real);
                    resVectors.get(i).set(1, "const");
                }
            }
        }

        //replace Macro
        for(int i = 0; i < resourceString.length(); i++) {
            if(resourceString.charAt(i) == '#' && i + 1 < resourceString.length() && resourceString.charAt(i + 1) == 'd') {
                //当前位置为#define
                i += 7;  //当前位置为e后面的空格
                while(resourceString.charAt(i) == ' ') {
                    i++;
                }//结束后位置为一个宏变量的开始符号
                int j = i;
                int k = i;
                while(resourceString.charAt(i) != ' ') {
                    i++;
                }//当前位置为变量后第一个空格
                String macroString = resourceString.substring(j, i);
                //System.out.println("待替换的变量为:" + macroString);
                String replaceString = "";
                for(Vector vector : resVectors) {
                    if(vector.get(0).equals(macroString)) {
                        replaceString = (String) vector.get(2);
                        //System.out.println(macroString + "替换为:" + replaceString);
                        break;
                    }
                }
                while(resourceString.charAt(i) == ' ') {
                    i++;
                }//当前结束为表达式第一个字符的位置
                j = i;
                while(resourceString.charAt(i) != '\n') {
                    i++;
                }
                StringBuilder builder = new StringBuilder(resourceString);
                builder.replace(j,  i, replaceString);
                resourceString = builder.toString();
                i = k;
                continue;
            }
        }

        int mainIndex = 0;
        for(int i = 0; i < resourceString.length(); i++) {
            if(resourceString.substring(i, i + 4).equals("main")) {
                mainIndex = i;
                break;
            }
        }

        String finalX = resourceString.substring(0, mainIndex);
        String finalY = resourceString.substring(mainIndex, resourceString.length());

        //替换主函数中的宏
        boolean flag = false;
        while(true) {
            flag = false;
            for(Vector vector : resVectors) {
                if(vector.get(1).equals("MACRO")) {
                    String macroString = (String) vector.get(0);
                    int index = finalY.indexOf(macroString);
                    if(index != -1) {
                        flag = true;
                        StringBuilder builder = new StringBuilder(finalY);
                        builder.replace(index, index + macroString.length(), (String) vector.get(2));
                        finalY = builder.toString();
                    }
                }
            }
            if(!flag) {
                break;
            }
        }

        //替换主函数中的表达式
        int index = 0;
        resourceString = finalX + finalY;
        String []subStrings = resourceString.split("\n");
        for(int i = 0; i < subStrings.length; i++) {
            if(subStrings[i].contains("define")) {
                continue;
            }
            if(subStrings[i].contains("=") && !subStrings[i].contains("3.14")) {
                int j = 0;
                //System.out.println("主函数中待替换: " + subStrings[i]);
                while (subStrings[i].charAt(j) == '\t' || subStrings[i].charAt(j) == ' ') {
                    j++;
                }//当前位置变量起始位置
                int k = j;
                while (subStrings[i].charAt(j) != ' ') {
                    j++;
                }//当前位置变量结束
                String varString = subStrings[i].substring(k, j);
                String replaceString = "";
                //search value
                for(Vector<String> vector : resVectors) {
                    if(vector.get(0).equals(varString)) {
                        replaceString = vector.get(2 + index++);
                        break;
                    }
                }
                subStrings[i] = subStrings[i].substring(0, k) + varString + " = " +
                        replaceString;
            }
        }
        resourceString = "";
        for(String xString : subStrings) {
            resourceString += (xString + "\n");
        }

        System.out.println("替换结束了");

        System.out.println(resourceString);
        RelativeLayout.LayoutParams lp = (RelativeLayout.LayoutParams) editText.getLayoutParams();
        lp.height = 1000;
        editText.setLayoutParams(lp);
        RelativeLayout.LayoutParams lp1 = (RelativeLayout.LayoutParams) editTextComp.getLayoutParams();
        lp1.height = 1300;
        editTextComp.setLayoutParams(lp1);
        SpannableStringBuilder builder = convert(resourceString);
        editText.setText(builder);
        editTextComp.setText(showProcess);
    }
}

5.2表达式检验

CheckAllExpression.java

/**
 * Date   : 2021/1/5 12:30
 * Author : KI
 * File   : CheckAllExpression
 * Desc   : check expression
 * Motto  : Hungry And Humble
 */
package com.example.compiler.Utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Vector;

public class CheckAllExpression {
    public Map<String, String> expMap = new LinkedHashMap<String, String>();
    String tab = "";
    public String resString = "";
    public ArrayList<String> mainExpArrayList = new ArrayList<>();
    Lexical_Analysis lexical_Analysis;
    Grammatical_Analysis grammatical_Analysis;
    Operator_Precedence operator_Precedence;
    ArrayList<String> Vt = new ArrayList<String>(Arrays.asList(
            ",", "=", "+=", "-=", "*=", "/=", "%=", "||", "&&", "|", "^", "&", "=", "!=",
            ">", ">=", "<", "<=", "<<", ">>", "+", "-", "*", "/", "%",  "!", "[]",
            "(", ")", "i", "#"));   //规定一个顺序
    ArrayList<String> Vn = new ArrayList<String>(Arrays.asList(
            "S", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N"));
    String []proRule = {"S->#A#", "A->A,B", "A->B", "B->C=B", "B->C+=B",
            "B->C-=B", "B->C*=B", "B->C/=B", "B->C%=B", "B->C", "C->C||D", "C->D",
            "D->D&&E", "D->E", "E->E|F", "E->F", "F->F^G", "F->G", "G->G&H",
            "G->H", "H->H=I", "H->H!=I", "H->I", "I->I>J", "I->I>=J", "I->I<J",
            "I->I<=J", "I->J", "J->J<<K", "J->J>>K", "J->K", "K->K+L", "K->K-L",
            "K->L", "L->L*M", "L->L/M", "L->L%M", "L->M", "M->!M", "M->N", "N->N[]N",
            "N->(A)", "N->i"};
    String procedure = "";
    public CheckAllExpression(String procedure, String tab) {
        this.tab = tab;
        lexical_Analysis = new Lexical_Analysis(procedure);
        lexical_Analysis.initNum();
        lexical_Analysis.mainFunc();
        this.procedure = procedure;
        grammatical_Analysis = new Grammatical_Analysis();
        operator_Precedence = new Operator_Precedence(Vn, Vt, proRule, tab);
    }

    public String convert(String xString) {
        xString = xString.trim();
        String resString = "";
        for(int i = 0; i < xString.length(); i++) {
            char char1 = xString.charAt(i);
            if(char1 == '(') {
                xString = xString.substring(0, i + 1) + " " + xString.substring(i + 1, xString.length());
                i++;
            }
            if(char1 == ')') {
                xString = xString.substring(0, i) + " " + xString.substring(i, xString.length());
                i++;
            }
        }
        String list[] = xString.split(" ");
        for(String yString : list) {
            if(yString.equals("(") || yString.equals(")") || Vt.contains(yString)) {
                resString += yString;
            }else {
                resString += "i";
            }
        }
        return resString;
    }

    public boolean checkMacro() {
        //convert("(ADD_t + (FR * tt + 100))");
        //先检查所有宏表达式定义的
        boolean resFlag = true;
        String []lineStrings = procedure.split("\n");
        ArrayList<String> tempArrayList = new ArrayList<String>();
        for(int k = 0; k < lineStrings.length; k++) {
            String xString = lineStrings[k];
            if(!xString.contains("define")) {
                continue;
            }
            if(xString.contains("define") && k + 1 < lineStrings.length && !lineStrings[k + 1].contains("main")) {
                //说明为宏定义语句
                for(int i = 0; i < lexical_Analysis.resVector.size(); i++) {
                    Vector<String> vector = lexical_Analysis.resVector.get(i);
                    if(vector.get(1).equals("MACRO") && !tempArrayList.contains(vector.get(0))) {
                        tempArrayList.add(vector.get(0));
                        String waitString = vector.get(2);  //待分析的表达式
                        resString += ("待分析的宏常量:" + vector.get(0) + "\n");
                        resString += ("待分析的表达式:" + waitString + "\n");
                        System.out.println("待分析的宏常量:" + vector.get(0));
                        System.out.println("待分析的表达式:" + waitString);
                        expMap.put(vector.get(0), waitString);
                        waitString = convert(waitString);
                        resString += ("转换后:" + waitString + "\n");
                        System.out.println("转换后:" + waitString);
                        operator_Precedence.processString = "";
                        boolean flag = operator_Precedence.check(waitString);
                        resString += operator_Precedence.processString;
                        operator_Precedence.processString = "";
                        if(flag) {
                            resString += ("Successful!" + "\n" + "\n");
                            System.out.println("Successful!");
                            System.out.println();
                        }else {
                            resFlag = false;
                            resString += ("failed!" + "\n" + "\n");
                            System.out.println("failed!");
                            System.out.println();
                        }
                    }
                }
            }
        }
        return resFlag;
    }


    public boolean checkMain() {
        boolean resFlag = true;
        String []lineStrings = procedure.split("\n");
        flag:for(String xString : lineStrings) {
            if(xString.contains("define") || xString.contains("include") || xString.contains("main") || xString.contains("{") || xString.contains("}")) {
                continue;
            }
            for(String yString : lexical_Analysis.keyWord) {
                if(xString.contains(yString)) {
                    continue flag;
                }
            }
            for(String yString : lexical_Analysis.function) {
                if(xString.contains(yString)) {
                    continue flag;
                }
            }
            resString += ("待分析的句子:" + xString + "\n");
            System.out.println("待分析的句子:" + xString);
            mainExpArrayList.add(xString);
            xString = convert(xString);
            resString += ("转换后:" + xString + "\n");
            System.out.println("转换后:" + xString);
            operator_Precedence.processString = "";
            boolean flag = operator_Precedence.check(xString);
            resString += operator_Precedence.processString;
            operator_Precedence.processString = "";
            if(flag) {
                resString += ("Successful!" + "\n" + "\n");
                System.out.println("Successful!");
                System.out.println();
            }else {
                resString += ("failed!" + "\n" + "\n");
                resFlag = false;
                System.out.println("failed!");
                System.out.println();
            }
        }
        return resFlag;
    }
}

5.3 完整代码

暂无。

Cyril_KI
关注
专栏目录
编译原理 实验1 编译预处理
2301_76979886的博客
09-18 2033
预处理器不仅是编译过程中最初的一环，更是整个构建过程的重要基础。良好的预处理可以减少编译时的错误，也为后续的编译分析提供了清晰、准确的输入。通过对预处理器的理解与应用，程序员能够写出更加灵活和维护性强的代码，提升编程效率。
编译原理——预处理（C++程序）
12-12
编译原理程序实例，实现预处理（删除多余空格、回车以及注释），C++源代码
编译原理课程设计----语法分析器(C语言)
04-06
该词法分析器是编译原理课程设计时的项目，使用c语言编写，文件夹中的大部分文件都是当时使用的参考文件，文件夹‘词法分析器’为完成的可以直接运行的词法分析器，解压后可以直接运行。
编译原理预处理源代码
12-02
采用C语言编写的编译原理预处理，功能完全实现，强力推荐下载分享！
C中预处理程序之小结
aliang775的专栏
12-30 405
预处理程序可能的动作：1. 包含其他文件 （#include /"filename"） 2. 定义符号常量和宏 （#define 符号常量/宏） 3. 程序代码的条件编译 （#ifdef和#ifndef） 4. 预处理指令的条件执行
编译原理实验之源程序的预处理及词法分析程序设计
野孩子的专栏
09-08 1万+
题目要求：     1、实现预处理功能 源程序中可能包含有对程序执行无意义的符号，要求将其剔除。 首先编制一个源程序的输入过程，从键盘、文件或文本框输入若干行语句，依次存入输入缓冲区（字符型数据）；然后编制一个预处理子程序，去掉输入串中的回车符、换行符和跳格符等编辑性文字；把多个空白符合并为一个；去掉注释。
基于安卓界面的编译原理课程设计：C语言的预处理程序+代码+文档说明
2301_79696294的博客
06-26 330
1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。下载后请首先打开README.md文件（如有），仅供学习参考, 切勿用于商业用途。
基于安卓界面的编译原理课程设计：C语言的预处理程序
最新发布
07-28
【作品名称】：基于安卓界面的编译原理课程设计：C语言的预处理程序 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：...
C语言入门：从预处理到跨平台HelloWorld实践
1. **预处理**：在程序编译之前，预处理是必不可少的步骤。预处理由预处理器完成，它处理#include指令（将头文件插入源代码中）、宏定义（替换文本）以及条件编译指令（根据特定条件决定代码是否被编译）。预处理是...
C语言条件编译：预处理指令详解
在Android开发中，例如标题提到的“条件编译指令-recyclerview+cardview实现横向卡片式滑动效果”，可能涉及到根据设备特性或应用配置选择不同的布局管理器或视图样式，从而优化用户体验。 预处理过程是编译过程的...
calculate简写_一些英文单词的标准缩写
weixin_39594439的博客
12-29 414
TRCompleteCompletionComplianceCMPLComponentCMPTWhen the meaning is "part", use abbreviation "PRT".CompositeCompensationCOMPConditionalCONDConfidentialCNFDConfirmConfirmation*CONF*ConstantCNSTCSTData w...
四则运算生成程序（基于控制台）
weixin_30462049的博客
09-26 359
四则混合运算（随机生成且含括号） git地址：https://github.com/dandan0502/arithmetic 项目完成情况 基本功能 完成情况 参与运算的操作数：100以内的整数，支持真分数 √ 运算符为 +, −, ×, ÷，运算符的种类和顺序必须随机生成 √ 要求能处理用户的输入，并判断对错，打分统计正确率。 √ 使用 -n 参数控制生成题目的个数 ...
Android-项目开发基础—C语言（十二）
Android、HTML、CSS、JS、JAVA、Kotlin、PHP等技术
08-13 985
JNIjava native interfacec的基本数据类型 int：32位，能表示的数字是2的32次方个 最高位用来表示符号位，那么还剩下31位可以表示数值，所以能表示的数字就是2的31次方个 int的表示范围： 当最高位是0时：0~2147483647 当最高位是1是：-2147483648~-1 java的基本数据类型长度 byte：1 short：2 int：4 long：8 bool
中缀表达式转后缀表达式，并计算结果（java）
LX__Mr的博客
09-21 1042
后缀表达式的计算机求值过程：（== 逆波兰表达式==） 从左至右扫描表达式，遇到数字时，就将数字压入栈中，遇到运算符时，就弹出栈顶的两个数字，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈；重复上述过程，直到表达式的最右端，最后运算得到的值就是表达式的结果 例：(3+4)×5-6对应的后缀表达式为 3 4 + 5 × 6，针对后缀表达式求值步骤如下： ①从左至右扫描，将3和4压入栈中； ②遇到运算符 + ，因此弹出 4 和 3（4 为栈顶元素， 3 为次顶元素），计算 3 + 4 的值，得到
Android中怎么用纯代码编写布局？
scyatcs的专栏
10-11 1万+
一、用RelativeLayout进行纯代码布局的理论基础      1、RelativeLayout，顾名思义，就是以“相对”位置/对齐 为基础的布局方式。      2、android.widget.RelativeLayout 有个继承自android.view.ViewGroup.LayoutParams 的内嵌类 LayoutParams，使用这个类的实例          调用R
单片机实验三：外部中断控制数码管循环显示0~9
热门推荐
KI的博客
12-03 12万+
设计单片机的Proteus仿真电路，实现如下功能：控制P0口数码管循环显示0-9； 按下上面开关，控制P2口数码管依次显示0-9；按下下面开关，控制P1口数码管依次显示0-9。
微机接口实验一：七段数码管循环动态显示00~99
KI的博客
12-05 11万+
利用8255A控制七段数码管循环动态显示00~99。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Cyril_KI

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

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

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

打赏作者

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

抵扣说明：

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

余额充值