精华内容
下载资源
问答
  • 编译原理实验,基本实现对程序的预处理功能 功能 去除部分的“回车符”或者“换行符” 去除注释(注释方式是以“//”开头的) 去除空格以及部分制表符 读取源程序,存储结果代码 完整代码 import java.io.*; ...

    背景

    编译原理实验,基本实现对程序的预处理功能

    功能

    1. 去除部分的“回车符”或者“换行符”
    2. 去除注释(注释方式是以“//”开头的)
    3. 去除空格以及部分制表符
    4. 读取源程序,存储结果代码

    完整代码

    import java.io.*;
    
    public class bianyiyuanli_preDeal {
        public static void main(String[] args) {
            int i =0, j = 0, k, l = 0;
            int t = 0, m = 0;
            int n = 1;
    
    
            BufferedReader reader=null;
            FileWriter fw=null;
    
            //String filePath="C:\\Users\\wangshibo\\Desktop\\2020在家学习\\编译原理\\PL-0-Compiler-master\\testPL0\\testPL1.txt";
            //String filePath = "D:\\idea项目文件夹\\testPL1.txt";
    
            try {
            	//设置编码,防止乱码
                InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("D:\\idea项目文件夹\\testPL1.txt"), "gbk");
                reader = new BufferedReader(inputStreamReader);
    
                char[] chars = new char[1024];
                StringBuffer sb = new StringBuffer();
    
                int youxiaoSting;
                while ((youxiaoSting = reader.read(chars)) != -1) {
                    sb.append(chars, 0, youxiaoSting);
                }
    
                char[] charss=new char[sb.length()];
                sb.toString().getChars(0,sb.length(),charss,0);
    
                char[] d = new char[sb.length()];
                char[] e = new char[sb.length()];
    
                for (k = 0; k < sb.length(); k++) {
                    //去除空格以及制表符
                    if ((charss[k] == 32 && charss[k + 1] == 32)||charss[k]==9||charss[k]==11) {
                        d[j] = (char)32;
                        l++;
    
                    }else {
                        d[j] = charss[k];
                        j++;
                    }
                }
    //            for (char ch : d) {
    //                System.out.print(ch);
    //            }
    
    
                for (k = 0; k < j; k++) {
                    //去除多余的“换行”或者“回车”
                    if ((d[k] == 10||d[k] == 13) && (d[k + 1] ==10||d[k + 1] ==13)) {
    
                        e[t]=d[k];
                        
                    } else if (d[k] == 47 && d[k+1] == 47) {//去除注释
                        int zhushi=k;
                        while (d[zhushi]!=(char)10 && d[zhushi]!=(char)13 ){
                            //System.out.println(d[zhushi]!=(char)10);
                            zhushi++;
                            k++;
                        }
                        k++;
                    }else {
                        e[t] = d[k];
                        t++;
                    }
                }
    //            for (char ch : e) {
    //                System.out.print(ch);
    //            }
                java.lang.String str = new java.lang.String(e, 0, t);
                System.out.print(str);
    
                fw=new FileWriter("D:\\idea项目文件夹\\testPL12.txt",false);
                fw.write(str);
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if (reader != null) {
                    try {
                        reader.close();
    
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (fw != null) {
                    try {
                        fw.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    备注

    1. 这个是我做实验用,肯定与实际编译器的真正预处理少了很多成分
    2. 并且这个是我自己打出来的,在处理效率上或许会有些许不足
    3. 若是这个大家发现有什么不足的地方,请留言指正
    展开全文
  • JAVA实现C语言预处理程序。 实现了C语言预处理程序的以下功能: 1.去除C语言源程序中的多余的空白符,将其合并成一个空格(或回车) 2.去除单行注释 3.去除多行注释
  • 设计并实现一个包含预处理功能的词法分析程序,加深对编译中词法分析过程的理解。 二、 实验要求 1、实现预处理功能 源程序中可能包含有对程序执行无意义的符号,要求将其剔除。 首先编制一个源程序的输入过程,从...

    一、 实验目的
    设计并实现一个包含预处理功能的词法分析程序,加深对编译中词法分析过程的理解。
    二、 实验要求
    1、实现预处理功能
    源程序中可能包含有对程序执行无意义的符号,要求将其剔除。
    首先编制一个源程序的输入过程,从键盘、文件或文本框输入若干行语句,依次存入输入缓冲区(字符型数据);然后编制一个预处理子程序,去掉输入串中的回车符、换行符和跳格符等编辑性文字;把多个空白符合并为一个;去掉注释。
    2、实现词法分析功能
    输入:所给文法的源程序字符串。
    输出:二元组(syn,token或sum)构成的序列。其中,
    syn为单词种别码。
    Token为存放的单词自身字符串。
    Sum为整型常量。
    具体实现时,可以将单词的二元组用结构进行处理。
    3、待分析的C语言子集的词法
    1)关键字
    main if then while do static int double struct break else long switch case typedef char return const float short continue for void default sizeof do
    所有的关键字都是小写。
    2)运算符和界符
    ** + - * / : := < <> <= > >= = ; ( ) # **
    3)其他标记ID和NUM
    通过以下正规式定义其他标记:
    ID→letter(letter|digit)*
    NUM→digit digit*
    letter→a|…|z|A|…|Z
    digit→0|…|9…
    4)空格由空白、制表符和换行符组成
    空格一般用来分隔ID、NUM、专用符号和关键字,词法分析阶段通常被忽略。
    4、各种单词符号对应的种别码
    表1 各种单词符号的种别码
    在这里插入图片描述

    5、 词法分析程序的主要算法思想
    算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号,其基本思想是根据扫描到的单词符号的第一个字符的种类,拼出相应的单词符号。
    其中初值包括如下两方面:
    (1) 关键字表初值
    关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符时,查关键字表。如能查到匹配的单词,则该单词为关键字,否则为一般标识符。关键字表为一个字符串数组,其描述如下:
    char *rwtab[27]={“main”,”if”,”then”,”while”,”do”,” static”,”int”,” double”,”struct”,”break”,”else”,”long”,”switch”,”case”,”typedef”,”char”,”return”,”const”,”float”,”short”,”continue”,”for”,”void”,”default”,”sizeof”,”do”};
    (2) 程序中需要用到的主要变量:syn,token和sum。
    2. 扫描子程序的算法思想
    首先设置三个变量:token用来存放构成单词符号的字符串;sum用来存放整型单词;syn用来存放单词符号的种别编码。

    Java源代码:

    import java.io.*;
    import java.io.FileReader;
    import java.io.FileWriter;
    
    public class test {
        public static void main(String ags[])
        {
            clearSpace cs=new clearSpace("d://文档/实验/test.txt");//处理文本目录,需要自行设置
            cs.readChar();  //从文件读取字符
            cs.clear();     //清空多余空白
            cs.writeChar("d://文档/实验/cleared.txt");  //将结果写入文件
            analyzeWord aw=new analyzeWord("d://文档/实验/cleared.txt",cs.t);
            aw.readChar();
            aw.analyze();   //进行分析并打印结果
        }
    }
    class clearSpace
    {
        FileReader fr=null;
        FileWriter fw=null;
        String fileAddress;
        char r[]=new char[1000];//保存读取字符
        char w[]=new char[1000];//保存有效字符
        int t;
        clearSpace(String fileAddress)
        {
            this.fileAddress=fileAddress;
        }
    
        public void readChar()
        {
            try {
                fr=new FileReader(fileAddress);
                int n;
                while ((n=fr.read(r))!=-1)
                {
                    //将文本数据读入字符数组
                    t=n;
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public void clear()
        {
            int i,j=0;
    
            for(i=0;i<t;i++)
            {
                if(r[i]==' ')//去掉多余空格
                {
                    if (w[j-1]!=' ') {
                        w[j++]=' ';
                    }
                    while(r[++i]==' ')
                    {
                    }
                    i--;
                }
                else if(r[i]=='\t') //去掉制表符
                {
                    if (w[j-1]!=' ') {
                        w[j++]=' ';
                    }
                    while(r[++i]=='\t')
                    {
                    }
                    i--;
                }
                else if(r[i]=='\n') //去掉换行
                {
                    if (w[j-1]!=' ') {
                        w[j++]=' ';
                    }
                    while(r[++i]=='\n')
                    {
                    }
                    i--;
                }
                else if(r[i]=='/' && r[i+1]=='/')   //去掉注释
                {
                    while (r[++i]!='\n')
                    {
                    }
                    i--;
                }
                else if(r[i]=='\r')   //去掉回车
                {
                    if (w[j-1]!=' ') {
                        w[j++]=' ';
                    }
                //    while (r[++i]!='\n')
                //    {
                //    }
                //    i--;
                }
                else{
                    w[j++]=r[i];    //其他字符
                }
            }
        }
    
        public void writeChar(String Address)
        {
            try {
                fw=new FileWriter(Address);
                fw.write(w);
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    class analyzeWord
    {
        String rwtab[]={" ","main","if","then","while","do","static","int","double","struct",
                        "break","else","long","switch","case","typedef","char","return","const",
                        "float","short","continue","for","void","sizeof"};
        String fileAddress;
        char rd[]=new char[1000];
    
        FileReader fr=null;
        int n,m=0,t;
        analyzeWord(String fileAddress,int t)
        {
            this.fileAddress=fileAddress;
            this.t=t;
        }
        public void readChar()
        {
            try {
                fr=new FileReader(fileAddress);
                while ((n=fr.read(rd))!=-1)
                {
                    //从文本中读取数据到字符数组
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    fr.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        public void analyze()
        {
            int i,j=0,syn=0;
            int c=0;
            char token[];
            char r[];
            String rds=new String(rd).trim();
            r=rds.toCharArray();
            for(i=0;i<r.length;i++)
            {
                token = new char[100];
                if((r[i]>='A'&& r[i]<='Z') || (r[i]<='z' && r[i]>='a'))
                {
                    while ((r[i]>='A'&& r[i]<='Z') || (r[i]<='z' && r[i]>='a') ||(r[i]>='0'&&r[i]<='9') )
                    {
                        token[j++]=r[i];
                        i++;
                    }
                    i--;
                    syn=25;     //先将syn赋值
                    String temp=new String(token).trim();
                    for(j=1;j<=24;j++)
                    {
                        if(temp.equals(rwtab[j]))
                        {
                            syn=j;  //如果存在关键字则重新赋值
                            break;
                        }
                    }
    
    
                }//识别字母开头的字母数字串
                else if(r[i]>='0'&&r[i]<='9')
                {
                    while ((r[i]>='0'&&r[i]<='9') )
                    {
                        token[j++]=r[i];
                        i++;
                    }
                    syn=26;
                    i--;
                }//识别数字NUM
                else if(r[i]==' ')
                {
                    continue;   //识别空格并直接进入下一次循环
                }
                else if(r[i]=='*'&&r[i+1]=='*') //识别**
                {
                    token[j++]='*';
                    token[j]='*';
                    syn=31;
                    i++;
                }
                else if(r[i]=='='&&r[i+1]=='=') //识别==
                {
                    token[j++]='=';
                    token[j]='=';
                    syn=32;
                    i++;
                }
                else if(r[i]=='<'&&r[i+1]=='>') //识别<>
                {
                    token[j++]='<';
                    token[j]='>';
                    syn=34;
                    i++;
                }
                else if(r[i]=='<'&&r[i+1]=='=') //识别<=
                {
                    token[j++]='<';
                    token[j]='=';
    
                    i++;syn=35;
                }
                else if(r[i]=='>'&&r[i+1]=='>') //识别>=
                {
                    token[j++]='>';
                    token[j]='=';
                    syn=37;
                    i++;
                }
                else {  //其他符号
                    token[j]=r[i];
                    switch (token[j])
                    {
                        case '+':
                            syn=27;
                            break;
                        case '-':
                            syn=28;
                            break;
                        case '*':
                            syn=29;
                            break;
                        case '/':
                            syn=30;
                            break;
                        case '<':
                            syn=33;
                            break;
                        case '>':
                            syn=36;
                            break;
                        case '=':
                            syn=38;
                            break;
                        case '[':
                            syn=39;
                            break;
                        case ']':
                            syn=40;
                            break;
                        case ';':
                            syn=41;
                            break;
                        case '(':
                            syn=42;
                            break;
                        case ')':
                            syn=43;
                            break;
                        case '#':
                            syn=0;
                            break;
                        default:
                            syn=-1;
                            break;
                    }
                }
                j=0;
                c++;
                if (syn==-1)
                {
                    System.out.print("(");
                    System.out.print(new String(token));
                    System.out.println(" ,无法识别该字符!)");
                }
                else {
                    System.out.print("(");
                    System.out.print(new String(token));
                    System.out.println(","+syn+")");
                }
            }
            System.out.println("词法分析完毕!");
        }
    }
    
    展开全文
  • java中基本类型的转换-编译器预处理
    public class Test {
    	public static void main(String[] args) {
    		byte a = 1;
    		byte b = 6;
    		byte c = a + b;//无法编译通过
    		byte d = 1+5;//编译通过,6在byte表数范围,使用发编译工具jd反编译class后得到的byte d = 6
    		byte e = 127+1;//无法编译通过,结果已经超出byte表数范围
    
    	}
    }
    总结:
    1.对于常量的运算,编译器会做预处理,会在编译时预处理运算后是否还在基本数据类型表数范围之内;
    2.对于变量的运算,因为无法确定运行时的状况,未避免失去精度,无法编译通过.
    展开全文
  • 一、编译预处理 我们直接举一个例子 package com.bjpowernode.java_learning; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; ...

    一、编译预处理

    • 我们直接举一个例子
    package com.bjpowernode.java_learning;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    public class D139_1_CompileProcess {
    	
    	public static void main(String[] args) {
    		Connection con = null;
    		PreparedStatement ps;
    		ResultSet rs = null;
    		
    		try {
    			Class.forName("com.hxtt.sql.access.AccessDriver");
    			String URL = "jdbc:Access:///e:xsgl.mdb";
    			con = DriverManager.getConnection(URL);
    		}catch(Exception e) {
    			
    		}
    		
    		try {
    			String update = "update tb_record set name=? where ID = ?";
    			ps = con.prepareStatement(update);
    			ps.setString(1,"项羽");
    			ps.setInt(2,4);
    			for(int i=0;i<10;i++) {
    				ps.setInt(2, i);
    				ps.setString(1, String.valueOf((char)(65+i)));
    				int rowCount = ps.executeUpdate();
    			}
    			ps.close();
    			con.close();
    		}catch(Exception e) {
    			
    		}
    	}
    
    }
    
    • 通过循环来给?处定义文字来进行升级操作。

    二、事务处理

    1.数据错误分类

    • (1)脏读(一个事务修改了某一行数据而未提交,另一事务读取了该行数据,假如前一个事务发生了回退,则后一个事务将得到一个无效的值。
    • (2)不可重复读
    • (3)错误读

    2.数据库事务具有的特征

    • 原子性(Atomic)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)

    3.常用事务处理方法

    类型隔离级别含义
    static intTRANSACTION-NONE不支持事务
    static intTRANSACTION-READ-COMMITED脏读,不可重复读和错误读取都是允许的
    static intTRANSACTION-READ-UNCOMMITED禁止脏读,不可重复读和错误读取都是允许的
    static intTRANSACTION-REPEATABLE-READ事务保证能够再次读取相同的数据而不会失败,错误读取是允许的
    static intTRANSACTION-SERIALIZABLE禁止脏读,不可重复读和错误读取
    • 用con.setTransactionIsolation(Connection.Isolationlevel);进行事务隔离级别的设置,Isolation_level取值即为表中5个常量。
    • 使用Connection中的三个方法来完成基本的事务管理。
    • (1)setAutoCommit(boolean true/false):设置自动提交属性AutoCommit,默认为true.
    • (2)rollback():回滚事务
    • (3)commit():事务提交。
    • 事务中可以有多个任务,一旦失败了,可以不回退,可以使用保存点(savepoint)来控制回滚的数量。所谓保存点,就是对事物的某些子任务设置符号标识,用来为回滚操作提供位置指示
    • 关于保存点的方法有以下三个:(1)setSavepoint(“保存点名称”):在某子任务前设置保存点;(2)releaseSavepoint(“保存点名称”):释放指定的保存点;(3)rollback(“保存点名称”):指示事务回滚到指定的保存点。

    三、源码:

    • D139_1_CompileProcess.java
    • D138_2_PreparedStatementDelete.java
    • https://github.com/ruigege66/Java/blob/master/D139_1_CompileProcess.java
    • https://github.com/ruigege66/Java/blob/master/D138_2_PreparedStatementDelete.java
    • CSDN:https://blog.csdn.net/weixin_44630050
    • 博客园:https://www.cnblogs.com/ruigege0000/
    • 欢迎关注微信公众号:傅里叶变换,个人账号,仅用于技术交流
    • 1000.0
    展开全文
  • 确实,从C ++过渡到Java的任何人都有他们最喜欢的涉及预处理器的恐怖故事。 故事中的对手总是《宏》 。 这个角色是一个恶魔般的骗子,诱使程序员认为较小等于更简单,因此更好。 但是Macro的最终目标是迷...
  • } } } 二、编译预处理 PreparedStatement始于编译预处理有关的类,是Statement的一个子类,它与Statement类的一个重要区别是:用Statement定义的语句是一个功能明确而具体的语句,而用PraparedStatement类定义的...
  • 编译原理 (预处理>编译>汇编>链接)

    千次阅读 2017-05-10 21:29:41
    转载http://www.cnblogs.com/pipicfan/archive/2012/07/10/2583910.html一般高级语言程序编译的过程:预处理编译、汇编、链接。gcc在后台实际上也经历了这几个过程,我们可以通过-v参数查看它的编译细节,如果想看...
  • 由于连接器对象调用createStatement()产生一个对象然后调用executeQuery(String sql)方法是将SQL语句发送到数据库然后数据库再将其编译成自己能...,那么通过预处理的目的就是将SQL语句先进行编译后在发送到数据库...
  • java中使用预处理的优势

    千次阅读 2017-10-25 17:19:00
    java中使用预处理的优势
  • 环境java1.8+oracle10+eclipse 今天在使用预编译进行模糊查询过程中有一个错误的写法 错误代码 sql.append(" and g.name like '%?%'"); 正确代码 sql.append(" and g.name like concat('%',?)||'%'"); //或者 sql....
  • 编译预处理(占位符) package test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.Statement; ...
  • #define add(x,y) x+y z = add(7,8); //此句在函数内部
  • 预处理编译

    2018-07-15 17:00:00
     预处理也称为预编译,它为编译做准备工作,主要进行代码文本的替换工作,用于处理#开头的指令,其中预处理产生编译器的输出。下表是一些常见的预处理指令及其功能。   经过预处理器处理的源程序与之前的源...
  • 编译的三种情况

    2012-09-16 20:12:27
    在C++中存在三种预编译的行为,1.宏展开 2.#include包含 3.条件限定#if #endif预判断 。 下面我们来逐一的分析这三种情况的用途。 1.宏:定义的格式为 #define PI 3.1415 //这就是一个宏定义。 它的优点:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,453
精华内容 11,781
关键字:

java编译预处理

java 订阅