编译原理——词法分析C语言程序JAVA源代码

最新推荐文章于 2024-04-12 16:10:56 发布
最新推荐文章于 2024-04-12 16:10:56 发布
阅读量1.2k 收藏 22
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57633498/article/details/121599762
版权

一、实验目的：

加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。

二、实验内容：

1．要识别的词素：

(1)保留字或关键字：如：BEGIN、 END、VAR、INTEGER、REAL、 IF、 THEN、READ、WRITE、WHILE。

(2)运算符： 如：+、-、*、/、:=、=、>、<、>=、<=

(3)标识符： 用户定义的变量名、常数名、过程名

(4)常数：   如：10、25、100、2.3等整数或实数

(5)界符：   如：‘,’、‘.’ 、‘;’ 、‘(’ 、‘)’、‘{’、‘}’，‘:’

2．词法分析过程所要完成的任务：

（1）给出源程序（要求一段完整的代码）

（2）滤空格

（3）识别保留字

（4）识别标识符

（5）拼数

（6）拼复合词（如:=）

（7）输出源程序的token(词法单元)序列。

需要进行词法分析的源程序：

 识别后的输出序列：

 

 

源代码：

package cifaapp;

import java.io.*;
import java.util.*;


//存放token序列
class token {
    Integer key;
    String value;
    token(Integer key, String value) {
        this.key = key;
        this.value = value;
    }
}
public class app {
	
	
	// 单词种别码, 1-17为关键字种别码
	public static final int CHAR = 1;
	public static final int SHORT = 2;
	public static final int INT = 3;
	public static final int LONG = 4;
	public static final int FLOAT = 5;
	public static final int DOUBLE = 6;
	public static final int FINAL = 7;
	public static final int STATIC = 8;
	public static final int IF = 9;
	public static final int ELSE = 10;
	public static final int WHILE = 11;
	public static final int DO = 12;
	public static final int FOR = 13;
	public static final int BREAK = 14;
	public static final int CONTINUE = 15;
	public static final int VOID = 16;
	public static final int RETURN = 17;
	public static String key[]={"char","short","int","long","float","double","final","static","if","else","while","do","for","break","continue","void","return"}; 
	// 20为标识符种别码
	public static final int ID = 20;

	// 30为常量种别码
	public static final int NUM = 30;

	// 31-40为运算符种别码
	public static final int AS = 31; // =
	public static final int EQ = 32; // ==
	public static final int GT = 33; // >
	public static final int LT = 34; // <
	public static final int GE = 35; // >=
	public static final int LE = 36; // <=
	public static final int ADD = 37; // +
	public static final int SUB = 38; // -
	public static final int MUL = 39; // *
	public static final int DIV = 40; // /

	// 41-49为界限符种别码
	public static final int LP = 41; // (
	public static final int RP = 42; // )
	public static final int LBT = 43; // [
	public static final int RBT = 44; // ]
	public static final int LBS = 45; // {
	public static final int RBS = 46; // }
	public static final int COM = 47; // ,
	public static final int COL = 48; // :
	public static final int SEM = 49; // ;

	// -1为无法识别的字符标志码
	public static final int ERROR = -1;
	public static int errorNum = 0; // 记录词法分析错误的个数

	
	
	public static LinkedList<String> list = new LinkedList<String>();
	public static LinkedList<token> tokenlist = new LinkedList<token>();
	//以行为单位读取文件内容
	public static void readFileByLines() {
		File file = new File("code.txt");
		BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));
            String tempString = null;
            // 一次读入一行，直到读入null为文件结束
            while ((tempString = reader.readLine()) != null) {
                //System.out.println(tempString);
                separate(tempString);
            }
            reader.close();
        } catch (IOException e) {} 
        
        finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e1) {}
            }
        }
	}
	//正则表达式分离字符串，放入链表中
	public static void separate(String linestring) {
		String temp[]=linestring.split("\\s+|\\n|(?<=\\+)|(?=\\+)|(?<=-)|(?=-)|(?<=\\*)|(?=\\*)|(?<=/)|(?=/)|(?<=\\>)|(?=\\>)|(?<=\\<)|(?=\\<)|(?<==)|(?==)|(?<=\\()|(?=\\()|(?<=\\))|(?=\\))|(?<=\\[)|(?=\\[)|(?<=])|(?=])|(?<=\\{)|(?=\\{)|(?<=})|(?=})|(?<=,)|(?=,)|(?<=:)|(?=:)|(?<=;)|(?=;)");
		for(int i=0;i<temp.length;i++) {
			list.add(temp[i]);
		}
	}
	
	public static void analyse() {
	    for (int i = 0; i < list.size(); i++) {
	        if (list.get(i).length() == 1) {
	            if (list.get(i).equals("=")) { // 运算符"="
	                if (list.get(i+1).equals("=")) { // 若后面跟的是"="，则是运算符"=="
	                	tokenlist.add(new token(EQ, list.get(i) + list.get(++i)));
	                } else { // 否则是运算符"="
	                	tokenlist.add(new token(AS, list.get(i)));
	                }
	            } else if (list.get(i).equals(">")) { // 运算符">"
	                if (list.get(i+1).equals("=")) { // 若后面跟的是"="，则是运算符">="
	                	tokenlist.add(new token(GE, list.get(i) + list.get(++i)));
	                } else { // 否则是运算符">"
	                	tokenlist.add(new token(GT, list.get(i)));
	                }
	            } else if (list.get(i).equals("<")) { // 运算符"<"
	                if (list.get(i+1).equals("=")) { // 若后面跟的是"="，则是运算符"<="
	                    tokenlist.add(new token(LE, list.get(i) + list.get(++i)));
	                } else { // 否则是运算符"<"
	                    tokenlist.add(new token(LT, list.get(i)));
	                }
	            } else if (list.get(i).equals("+")) { // 运算符"+"
	                if ((list.get(i-1).equals("=") || list.get(i-1).equals("("))
	                    && isNum(list.get(i+1))) { // 判断是否是有符号常量（正数）
	                    tokenlist.add(new token(NUM, list.get(i) + list.get(++i)));
	                } else { // 否则是运算符"+"
	                    tokenlist.add(new token(ADD, list.get(i)));
	                }
	            } else if (list.get(i).equals("-")) { // 运算符"-"
	                if ((list.get(i-1).equals("=") || list.get(i-1).equals("("))
	                        && isNum(list.get(i+1))) { // 判断是否是有符号常量（负数）
	                    tokenlist.add(new token(NUM, list.get(i) + list.get(++i)));
	                } else { // 否则是运算符"-"
	                    tokenlist.add(new token(SUB, list.get(i)));
	                }
	            } else if (list.get(i).equals("*")) { // 运算符"*"
	                tokenlist.add(new token(MUL, list.get(i)));
	            } else if (list.get(i).equals("/")) { // 运算符"/"
	                tokenlist.add(new token(DIV, list.get(i)));
	            } else if (list.get(i).equals("(")) { // 界限符"("
	                tokenlist.add(new token(LP, list.get(i)));
	            } else if (list.get(i).equals(")")) { // 界限符")"
	                tokenlist.add(new token(RP, list.get(i)));
	            } else if (list.get(i).equals("[")) { // 界限符"["
	                tokenlist.add(new token(LBT, list.get(i)));
	            } else if (list.get(i).equals("]")) { // 界限符"]"
	                tokenlist.add(new token(RBT, list.get(i)));
	            } else if (list.get(i).equals("{")) { // 界限符"{"
	                tokenlist.add(new token(LBS, list.get(i)));
	            } else if (list.get(i).equals("}")) { // 界限符"}"
	                tokenlist.add(new token(RBS, list.get(i)));
	            } else if (list.get(i).equals(",")) { // 界限符","
	                tokenlist.add(new token(COM, list.get(i)));
	            } else if (list.get(i).equals(":")) { // 界限符":"
	                tokenlist.add(new token(COL, list.get(i)));
	            } else if (list.get(i).equals(";")) { // 界限符";"
	                tokenlist.add(new token(SEM, list.get(i)));
	            } else if (list.get(i).charAt(0) >= '0' && list.get(i).charAt(0) <= '9') { // 判断是否是一位数字常量
	                tokenlist.add(new token(NUM, list.get(i)));
	            } else if (isLetter(list.get(i).charAt(0))) { // 判断是否是一位字母标识符
	                tokenlist.add(new token(ID, list.get(i)));
	            } else { // 否则是无法识别的字符
	                tokenlist.add(new token(ERROR, list.get(i)));
	                errorNum++;
	            }
	        } else if ((list.get(i).charAt(0) >= '0' && list.get(i).charAt(0) <= '9')
	                    || list.get(i).charAt(0) == '.') { // 判断是否是正确的常量
	            if (!isNum(list.get(i))) { // 不是常量，则是无法识别的字符
	                tokenlist.add(new token(ERROR, list.get(i)));
	                errorNum++;
	            } else if ((list.get(i+1).charAt(0) == '+' || list.get(i+1).charAt(0) == '-')
	                    && isNum(list.get(i+2))) { // 判断是否是有符号的常量
	                tokenlist.add(new token(NUM, list.get(i) + list.get(++i) + list.get(++i)));
	            } else { // 否则是无符号的常量
	                tokenlist.add(new token(NUM, list.get(i)));
	            }
	        } else if (isKeyID(list.get(i)) != 0) { // 判断是否为关键字
	            tokenlist.add(new token(isKeyID(list.get(i)), list.get(i)));
	        } else if (isLetter(list.get(i).charAt(0)) || list.get(i).charAt(0) == '_') { // 判断是否为标识符（以字母或者下划线开头）
	            tokenlist.add(new token(ID, list.get(i)));
	        } else { // 否则是无法识别的单词
	            tokenlist.add(new token(ERROR, list.get(i)));
	            errorNum++;
	        	}
	    	}
	    }
	  //判断是否为数字
	    public static boolean isNum(String str){
	       for (int i = str.length();--i>=0;){
	           if (!Character.isDigit(str.charAt(i))){
	               return false;
	           }
	       }
	       return true;
	    }
	    //判断是否为关键字
	    static int isKeyID(String s){
	    	 int i;
	    	 for(i=0;i<6;i++){
	    		 if(s.equals(key[i])) {
	    			 return i;
	    		 }
	    	 }
	    		  return 0;
	    }
	    static boolean isLetter(char c)
	    {
	     if(c>='a' && c<='z')
	      return true;
	     return false;
	    }
	    
	public static void main(String args[]) {
		readFileByLines();
		analyse();
		
		System.out.println(list);
		System.out.println("词法分析结果如下：\n<单词种别码，单词>          //所属类别");
		for(int i=0;i<tokenlist.size();i++){
			System.out.print("<   " + tokenlist.get(i).key + "    " + tokenlist.get(i).value + "  >          ");
			if (tokenlist.get(i).key > 0 && tokenlist.get(i).key < 20) {
		        System.out.println("//关键字");
		    } else if (tokenlist.get(i).key == 20) {
		        System.out.println("//标识符");
		    } else if (tokenlist.get(i).key == 30) {
		        System.out.println("//常量");
		    } else if (tokenlist.get(i).key > 30 && tokenlist.get(i).key <= 40) {
		        System.out.println("//运算符");
		    } else if (tokenlist.get(i).key > 40 && tokenlist.get(i).key < 50) {
		        System.out.println("//界限符");
		    } else if (tokenlist.get(i).key == -1) {
		        System.out.println("//无法识别的符号");
		    }
		}
		System.out.println("词法分析结束！共" + errorNum + "个无法识别的符号");
	}
}

小白花lll
关注
  • 0
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
编译原理，词法分析代码实现，C语言程序，保证能运行
09-21
课程：编译原理 实现：编译过程第一步“词法分析代码实现“” 语言：C语言程序 保证能运行 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 各种单词符号对应的种别码：（1）关键字 （2）运算符和界...
编译原理——词法分析器
12-21
词法分析是编译原理中的一个重要环节，它是编译器前端的第一步，主要负责将源代码分解成一个个有意义的符号，这些符号被称为“记号”（Token）。在类C语言中，记号主要包括关键字、标识符、常量、运算符、分隔符等。...
【编译原理】简单词法分析程序的实现C语言
qq_51639901的博客
03-27 9914
编译原理课程的实验二：编制简单词法分析程序。 实验内容：通过了解词法分析程序的功能，设计词法分析程序，通过逐个字符的扫描和分解，能够识别出一个一个单词以及单词的分类；删除注释并进行词法检查，报告所发现的错误（比如标识符不能以数字开头，123aaa就不是合法的标识符），建立符号表。 实验说明：单词通常分为五种类型： （1）基本字：（关键字，保留字）如if else int break等 （2）运算符：如+ - * / = ...
编译原理(词法分析) Java 实现
assiduous_me的博客
05-24 1515
1. 项目目录 2. 需要解释的源代码 PROGRAM SOURCE; /*定义变量*/ VAR X, Y, Z:INTEGER; A:INTEGER; B:INTEGER; //程序开始 BEGIN X := 5; A := 0; WHILE X > 0 DO A := A + X; A := X - 1; IF A = 10 THEN B ...
词法分析程序设计与实现(C语言)
最新发布
Cha3043445754的博客
04-12 448
【代码】词法分析程序设计与实现(C语言)
c语言实现词法分析器
zmm0628的博客
11-17 3万+
词法分析器的功能:输入源程序，输出单词字符。单词字符一般可以分为下面五种。 （1）关键字 是由程序语言定义的具有固定意义的标识符。有时称这些标识符为保留字或者基本字。例如c语言中的int,char,define,strcut,double,if,else.等等 （2）标识符 用来表示各种名字，如变量名，数组名，过程名。 （3）常数 常数的类型一般有整形，实型，布尔型等 （4）运算符 如+，-，*，/。 （5）界符 如逗号，分号，括号，%，//，等。 词法分析器的目标就是把程序分成一个一个单词。并给出单词符号
编译原理_实验一 _词法分析 （Java实现及代码解析）
Aleutian的博客
10-23 1266
编译原理_实验一 _词法分析 （Java实现及代码解析）
编译原理实验一（C-语言词法分析器的编写C语言版本）
哈哈哈哈哈哈哈哈的博客
11-07 7685
编译原理实验一（C-语言词法分析器的编写C语言版本） 1.词法规则 ①语言的关键字： else if int return void while 所有的关键字都是保留字，并且必须是小写。 ②专用符号： + - * / < <= > >= == != = ; , ( ) [ ] { } /* */ ③其他标记是I D和N U M，通过下列正则表达式定义： ID = letter letter* NUM = digit digit* let..
编译原理 实验一 词法分析器
热门推荐
just_a_new_life
07-03 10万+
编写一个词法分析程序
用C语言实现简单的词法分析器
ben_xiao_hai的专栏
08-13 1万+
词法分析器又称扫描器。词法分析是指将我们编写的文本代码流解析为一个一个的记号，分析得到的记号以供后续语法分析使用。词法分析器的工作是低级别的分析：将字符或者字符序列转化成记号.。 要实现的词法分析器单词符号及种别码对照表： 单词符号 # begin if then while do End + - * / : : = 种别码
编译原理实验（一）——词法分析器的设计（C语言版）.zip
01-08
在本实验中，我们主要探讨的是编译原理中的一个关键环节——词法分析器的设计，这一部分是构建编译器的基础。编译原理是计算机科学领域的重要学科，它研究如何将高级编程语言转换为机器可执行的指令。在这个实验中，...
java词法分析器源代码
12-11
java词法分析器源代码，用eclipse打开就行，免费下载哦，
词法分析器，c语言源程序
10-31
词法分析器，c语言源程序 这是我自己写的，老师检查也通过了。 好好看看吧！
编译原理词法分析器（C++版）源代码
01-05
自己实现的编译原理的词法分析器，是自己的实验作业，用Vs2017实现，可以直接运行，代码注释丰富，希望与大家交流学习！欢迎大家下载！
编译原理词法分析器与语法分析器源代码&实验报告
05-18
本资源包括了编译原理这门课程所要求的两次实验——编写词法分析器和语法分析器的源代码及实验报告，对于没有头绪的同学们是一个很好的参考，可以有效的帮助你们打开思路
编译原理--词法分析器+语法分析器 源代码
01-07
词法分析器：1) 定义目标语言的可用符号表和构词规则； 2) 依次读入源程序符号，对源程序进行单词切分和识别，直到源程序结束； 3) 对正确的单词，按照它的种别以的形式保存在符号表中； 4) 对不正确的单词，做出错误处理。 算符优先算法： 若输入文法： E->E+T | T T->T*F | F F-> (E) | i 根据算符优先分析法，将赋值语句进行语法语义分析，翻译成等价的一组基本操作，每一基本操作用四元式表示
C语言词法分析程序(编译原理)
06-21
本项目聚焦于C语言的词法分析，通过利用C语言的文件读写功能，实现对源代码的解析，生成token值并保存到新文件中，为后续的语法分析和编译工作打下基础。 词法分析，又称扫描，是将源代码文本分解成一系列有意义的...
杭电编译原理实验——简单C语言语法分析器
09-20
在这个实验中，我们将聚焦于“杭电编译原理实验——简单C语言语法分析器”，这是一个旨在帮助学生深入理解词法分析概念的实际操作项目。** **词法分析**是编译过程的第一步，它的主要任务是将源代码分解成一系列有...
简单C语言词法分析器（C++实现）
萧十一的技术小站
10-09 8415
该程序实现了对C语言中变量、整数、符号及部分保留字的词法分析，下面给出各单词符号与种别码的对应关系。1：保留字: int,double,char,if,else,for,while,do,return,break,continue,main 2：变量：以下划线或字母开头的数字字母串，中间可混有下划线，例：_abc1_bcd 3：整数：任意的数字串，程序可将其转化为对应的整型量 4：运算符：+
编译原理————词法分析器c语言代码
12-10
编译原理是计算机科学中的一个重要分支，主要研究如何将高级语言转换为机器语言的过程。其中，词法分析器是编译器中的一个重要组成部分，它负责将源代码中的字符序列转换为有意义的单词序列，也就是词法单元。 下面是一个简单的词法分析器的C语言代码示例： ```c #include <stdio.h> #include <ctype.h> #include <string.h> #define MAX_TOKEN_LEN 100 typedef enum { INT, FLOAT, IDENTIFIER, KEYWORD } TokenType; typedef struct { TokenType type; char value[MAX_TOKEN_LEN]; } Token; char *keywords[] = {"if", "else", "while", "for", "int", "float"}; int is_keyword(char *word) { int i; for (i = 0; i < 6; i++) { if (strcmp(word, keywords[i]) == 0) { return 1; } } return 0; } Token get_token() { Token token; char c = getchar(); while (isspace(c)) { c = getchar(); } if (isdigit(c)) { token.type = INT; int i = 0; while (isdigit(c)) { token.value[i++] = c; c = getchar(); } if (c == '.') { token.type = FLOAT; token.value[i++] = c; c = getchar(); while (isdigit(c)) { token.value[i++] = c; c = getchar(); } } token.value[i] = '\0'; ungetc(c, stdin); } else if (isalpha(c) || c == '_') { token.type = IDENTIFIER; int i = 0; while (isalnum(c) || c == '_') { token.value[i++] = c; c = getchar(); } token.value[i] = '\0'; ungetc(c, stdin); if (is_keyword(token.value)) { token.type = KEYWORD; } } else { token.type = c; } return token; } int main() { Token token; do { token = get_token(); switch (token.type) { case INT: printf("INT: %s\n", token.value); break; case FLOAT: printf("FLOAT: %s\n", token.value); break; case IDENTIFIER: printf("IDENTIFIER: %s\n", token.value); break; case KEYWORD: printf("KEYWORD: %s\n", token.value); break; default: printf("%c\n", token.type); break; } } while (token.type != EOF); return 0; } ``` 这个词法分析器可以识别整数、浮点数、标识符和关键字。它通过一个`get_token()`函数来获取下一个词法单元，并根据单元的类型进行相应的处理。在`get_token()`函数中，它会读取输入流中的字符，根据字符的类型来判断当前单元的类型，并将单元的值存储在一个`Token`结构体中返回。在`main()`函数中，它会不断调用`get_token()`函数来获取下一个单元，并根据单元的类型进行相应的输出，直到读取到输入流的结尾。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值