编译原理-词法分析

于 2021-05-28 11:27:06 发布
阅读量335 收藏 1
点赞数 1
分类专栏： 编译原理 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47355351/article/details/117356654
版权

给出一个简单程序语言的语法结构

在这里插入图片描述

单词种类编码

在这里插入图片描述

代码实现

主方法

package com.cheng.wordAnalyzer;

import java.util.ArrayList;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
    String analyzePath="D:\\�ҵ��ļ�\\������\\complierTheory/word.txt";//存放程序的文件
    WordAnalyzer analyze=new WordAnalyzer(analyzePath);
    ArrayList<ArrayList<WordKind>> staff=analyze.analyze();
    String savePath="D:\\�ҵ��ļ�\\������\\complierTheory/save.txt";//分析后保存在此文件中
    AnalyzeResult result=new AnalyzeResult(staff,savePath);
    result.save();
    /*
    String s="$2555ld";
    String regex="([\\p{Alpha}]+[_]?[\\p{Digit}]*)|[$][\\p{Alnum}]+";
    System.out.println(s.matches(regex));
    
    String s="abcd_sdsd";
    for(int i=0;i<s.length();i++) {  
		  String ch=String.valueOf(s.charAt(i));//�����ڸ��±��µ��ַ�
		 
		  if("_".equals(ch)) {
			  System.out.println("********************************************");
		  }
    }
    */
    //System.out.println(ch=="_");
	}

}

单词编码

package com.cheng.wordAnalyzer;

public class WordKind {
    String string;
    String type;
    int code;
    public WordKind(char ch) {
    	this.string=String.valueOf(ch);
    	
    }
	public WordKind(String ch) {
		this.string = ch;
		
	}
	
	public String getString() {
		return string;
	}
	public void setString(String string) {
		this.string = string;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public void coding() {
		int flag=0;//判断是否属于下列switch中的
		switch(string){       //数据类型编码，包括基本数据类型、布尔类型、关键字，运算符
		case "+":
			this.type="operator";
			this.code=100;
			break;
		case "-":
			this.type="operator";
			this.code=101;
			break;
		case "*":
			this.type="operator";
			this.code=102;
			break;
		case "/":
			this.type="operator";
			this.code=103;
			break;
		case "(":
			this.type="operator";
			this.code=104;
			break;
		case ")":
			this.type="operator";
			this.code=105;
			break;
		case "{":
			this.type="operator";
			this.code=106;
			break;
		case "}":
			this.type="operator";
			this.code=107;
			break;
		case "=":
			this.type="operator";
			this.code=108;
			break;
		case ".":
			this.type="operator";
			this.code=109;
			break;
		case "'":
			this.type="operator";
			this.code=110;
			break;
		case "\"":
			this.type="operator";
			this.code=111;
			break;
		case "%":
			this.type="operator";
			this.code=112;
			break;
		case "&":
			this.type="operator";
			this.code=113;
			break;
		case "!":
			this.type="operator";
			this.code=114;
			break;
		case "[":
			this.type="operator";
			this.code=115;
			break;
		case "]":
			this.type="operator";
			this.code=116;
			break;
		case "|":
			this.type="operator";
			this.code=117;
		 	break;
		case "boolean":
			this.type="datatype";
			this.code=118;
		 	break;
		case "byte":
			this.type="datatype";
			this.code=119;
		 	break;
		case "short":
			this.type="datatype";
			this.code=120;
		 	break;
		case "int":
			this.type="datatype";
			this.code=121;
		 	break;
		case "long":
			this.type="datatype";
			this.code=122;
		 	break;
		case "float":
			this.type="datatype";
			this.code=123;
		 	break;
		case "double":
			this.type="datatype";
			this.code=124;
		 	break;
		case "char":
			this.type="datatype";
			this.code=125;
		 	break;
		case "true":
			this.type="constant";
			this.code=126;
		 	break;
		case "false":
			this.type="constant";
			this.code=127;
		 	break;
		case "for":
			this.type="key";
			this.code=128;
		 	break;
		case "if":
			this.type="key";
			this.code=129;
		 	break;
		case "else":
			this.type="key";
			this.code=130;
		 	break;
		case "while":
			this.type="key";
			this.code=131;
		 	break;
		case "do":
			this.type="key";
			this.code=132;
		 	break;
		case "continue":
			this.type="key";
			this.code=133;
		 	break;
		case "switch":
			this.type="key";
			this.code=134;
		 	break;
		case "case":
			this.type="key";
			this.code=135;
		 	break;
		case "break":
			this.type="key";
			this.code=136;
		 	break;
		case "abstract":
			this.type="key";
			this.code=137;
		 	break;
		case "assert":
			this.type="key";
			this.code=138;
		 	break;
		case "catch":
			this.type="key";
			this.code=139;
		 	break;
		case "class":
			this.type="key";
			this.code=140;
		 	break;
		case "const":
			this.type="key";
			this.code=141;
		 	break;
		case "default":
			this.type="key";
			this.code=142;
		 	break;
		case "enum":
			this.type="key";
			this.code=143;
		 	break;
		case "extends":
			this.type="key";
			this.code=144;
		 	break;
		case "finally":
			this.type="key";
			this.code=145;
		 	break;
		case "goto":
			this.type="key";
			this.code=146;
		 	break;
		case "public":
			this.type="key";
			this.code=147;
		 	break;
		case "void":
			this.type="key";
			this.code=148;
		 	break;
		case "packet":
			this.type="key";
			this.code=149;
		 	break;
		case "import":
			this.type="key";
			this.code=150;
		 	break;
		case ";":
			this.type="symbol";
			this.code=151;
		 	break;
		case ",":
			this.type="symbol";
			this.code=152;
		 	break;
		case "^":
			this.type="operator";
			this.code=153;
		 	break;
		case "#":
			this.type="operator";
			this.code=154;
		 	break;
		 default:flag=1;
	   }
		if(flag==1) {
			if(this.isDigital()) {
				this.type="digital";    //数字
				this.code=200;
			}
			else if(this.isIdentifier()){
				this.type="identifier";  //标识符
				this.code=201;
			}else {
				this.type="other"; //其他
				this.code=202;
			}
		}
		
	  }
	public boolean isDigital() {//判断是否是数字，用正则表达式匹配
		String regex="[0-9]+[\56]?[0-9]*";
	    return (string.matches(regex));
	}
	public boolean isIdentifier() { //匹配是否是标识符
		//String regex="([\\p{Alpha}]+[_]+[\\p{Digit}]*)|([$]+[\\p{Alnum}]+[_]*[\\p{Alnum}]*)|([_]+[\\p{Alnum},$]+)";
		String regex="[_,$,\\p{Alpha}]+[\\p{Alnum},_,$]*";
		return (string.matches(regex));
	}
    
}

对整个文件进行分析，拆分

package com.cheng.wordAnalyzer;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class WordAnalyzer {
   String path;
   public WordAnalyzer(String path) {
	   this.path=path;
	   
   }
   public ArrayList<ArrayList<WordKind>> analyze() {
	   ArrayList<ArrayList<WordKind>> staff=new ArrayList<>();
	   try {   
		   File file=new File(path);
		   FileReader fileReader=new FileReader(file);
		   BufferedReader bufferedReader=new BufferedReader(fileReader);
		   String s=null;
		   while((s=bufferedReader.readLine())!=null) {
//			   if(s.length()==0) {
//				   continue;
//			   }
			   /**
			        * 对文件的每一行进行拆分，按照空格
			    */
			   StringTokenizer analyze=new StringTokenizer(s);
			   for(int i=0;analyze.hasMoreTokens();i++) {
				   String str=analyze.nextToken();
				   WordAnalyze wordAnalyze=new WordAnalyze(str);
				   staff.add(wordAnalyze.split());
			   }
		   }
		   
		   bufferedReader.close();
		   fileReader.close();
		   
		   }catch(IOException e){
			   e.printStackTrace();
		   }
	   return staff;
   }
   
	
}

对文件中的连在一起的句子进行分析拆分

package com.cheng.wordAnalyzer;

import java.util.ArrayList;



public class WordAnalyze {
	  String s;
      WordAnalyze(String str) {
	  this.s=str;
   }
      public ArrayList<WordKind> split(){
    	  ArrayList<WordKind> staff=new ArrayList<>();
    	  int length=s.length();
    	  int first=0;
    	  for(int i=0;i<length;i++) {  
    		  String ch=String.valueOf(s.charAt(i));//保存在该下标下的字符
    		  
    		  if(ch.equals("_")) {
    			  //System.out.println("********************************************");
    		  }
    		  else if(ch.equals("$")) {
    			  
    		  }
    		  else if(ch.equals(".")) {
    			 // System.out.println("********************************************");
    			  if(first==i) {
    				  WordKind word=new WordKind(ch);
    				  word.coding();
    				  staff.add(word);
    				  System.out.println(ch);
     				  first=i+1;    				  
     			 }else {
     				//System.out.println("********************************************");
	     			 if(i!=0&&i!=length-1) {
		     			 if(Character.isDigit(s.charAt(i-1))&&Character.isDigit(s.charAt(i+1))) {
		     				 
		     			 }else {
		    				String str=s.substring(first, i);
		    				WordKind word=new WordKind(str);
		    				word.coding();
		    				staff.add(word);
		     				System.out.println(s.substring(first, i));
		     				System.out.println(ch);
		     				WordKind word1=new WordKind(ch);
		    				word1.coding();
		    				staff.add(word1);
		     			    first=i+1;		     			     
		     			 }    			 
	     			 }
     			 }
    		  }else {
    			  //System.out.println("********************************************");
    			  String regex="\\p{Punct}";//匹配标点符号
    		      if(ch.matches(regex)) {
    		    	  if(first==i) {
        				  WordKind word=new WordKind(ch);
        				  word.coding();
        				  staff.add(word);
        				  //System.out.println(ch);
         				  first=i+1;    				  
         			 }else {
    		    	    String str=s.substring(first, i);
	    				WordKind word=new WordKind(str);
	    				word.coding();
	    				staff.add(word);
	     				//System.out.println(s.substring(first, i));
	     				//System.out.println(ch);
	     				WordKind word1=new WordKind(ch);
	    				word1.coding();
	    				staff.add(word1);
	     			    first=i+1;	
         			 }
    		      }
    		  }		      		  
    	  }
    	  if(first<length) {
    		   String str=s.substring(first, length);
				WordKind word=new WordKind(str);
				word.coding();
				staff.add(word);
    		    //System.out.println(s.substring(first, length));
    	  }
    	  return staff;
      }
}

分析结果保存

package com.cheng.wordAnalyzer;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class AnalyzeResult {
	ArrayList<ArrayList<WordKind>> list;
	String savePath;
	public AnalyzeResult(ArrayList<ArrayList<WordKind>> list,String savePath) {
		this.list=list;
		this.savePath=savePath;	
	}
	public void save() {
		if(list==null) {
			return ;
		}else {
			try {
				File file=new File(savePath);
				FileWriter fileWriter=new FileWriter(file);
				BufferedWriter bufferedWriter=new BufferedWriter(fileWriter);
				String str="行数\\t单词符号\\t单词编码\\t单词种类";
				int count=1;
				bufferedWriter.write(str);
				bufferedWriter.newLine();
				int listSize=list.size();
			    for(int i=0;i<listSize;i++) {
					ArrayList<WordKind> listChild=list.get(i);
					int listChildSize=listChild.size();
					for(int j=0;j<listChildSize;j++) {
						WordKind wordKind=listChild.get(j);
						String str1="第"+count+"行\t"+wordKind.string+"\t"+wordKind.code+"\t"+wordKind.type;
						bufferedWriter.write(str1);
						bufferedWriter.newLine();
						count++;
					}
		     	}
			    bufferedWriter.flush();
			    bufferedWriter.close();
			    fileWriter.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
			
		}
	}
	
}
N-Ge
关注
专栏目录
Java实现编译原理词法分析
影龙武的博客qq_43594119
04-08 370
Java实现编译原理词法分析 题目 前提条件 输入终止条件 字符#表示输入终止 变量命名规则 变量名只能为字母、数字、下划线的组合，且只能以字母或下划线开头 考虑可能出现的不规范输入 变量赋值没有用空格隔开，如 x:=9; 或 x :=9; 规范输入应该是 x := 9; 思路 代码 ...
编译原理实验——词法分析程序(条理清晰，注释详细)
qq_38902844的博客
11-09 4091
前言 在此程序中，我将单词符号分成以下6类： 关键字，也称保留字，如int、while、if、return等 标识符，用来表示各种名字，如变量名、函数名等 常数，如整数、实数、字符串等 运算符，如+、-、*、/ 等 界符，如逗号、分号、括号等 注释 输入 需要事先把要分析的代码保存到一个和源文件相同目录的文件中，在本程序中使用的是test.txt文件。当然，你也可以自定义。 文件内容如下： 注：这个文件中的代码可能并不完全符合语法，只是为了测试使用 #include <stdio.h>
C语言实现词法分析器
热门推荐
summer_lover_的博客
10-19 1万+
我们都知道，要执行一个C语言的代码，要编译链接。编译就是把文本形式源代码翻译为机器语言形式的目标文件的过程。链接是把目标文件、操作系统的启动代码和用到的库文件进行组织形成最终生成可执行代码的过程。我们用到的编写C语言的编辑器，你将写好的代码点击了一下编译，那么这些代码会被送到一个编译程序里面，将它转换为机器代码。那么编译器又是如何运作的呢？编译程序的工作过程可以划分为五个阶段：词法分析，语法分析，语
词法分析器实验报告
weixin_30839881的博客
03-29 1214
词法分析器实验报告 1.实验平台： visualstudio2010 2.实验目的 设计、编制、调试一个词法分析子程序－识别单词，加深对词法分析原理的理解。 3.数字状态转换图： 4本程序自行规定： (1)关键字"begin","end","if","then","else","while","write","read", "do","call","const"...
编译原理实验一【词法分析程序设计】
今天你AC了吗
12-30 4832
基本要求： ①掌握程序语言的词法结构。 ②掌握状态转换图的使用。 ③掌握设计词法分析程序的一般方法。 ④学会熟练调式程序。 重点及难点：掌握用状态转换图描述程序词法结构的一般方法，并在此基础上完成简版C语言子集词法分析程序的设计和调试运行。 一、 C语言子集的单词符号表示 一个非常重要的事实是：大多数程序语言的单词符号都可以用状态转换图予以识别。作为本次实验，我们来构造一个C语言子集的简单词法分析器。下表列出了这个C语言子集的所有单词符号以及它们的种别编码和内码值。由于直接使用整数编码不利于记忆，故该程序中
编译原理-词法分析设计原理与实现技术
01-20
本篇文章将深入探讨“编译原理-词法分析设计原理与实现技术”，以及在“编译原理实验一”中的应用。 词法分析，又称为扫描或词法分解，是编译过程的第一步。它的主要任务是从源代码文本中识别出一个个有意义的单元...
编译原理 - 词法分析：C/C++实现
11-15
通过这次实验，我深入了解了词法分析的过程和原理，并体会到了其在编译过程中的重要性和作用。在这个过程中，我遇到了一些困难，但也获得了宝贵的经验和收获。首先，词法分析是编译过程中的第一个阶段，负责将源代码...
编译原理-词法分析实验（c++版）
05-22
请根据给定的文法设计并实现词法分析程序，从源程序中识别出单词，记录其单词类别和单词值，输入输出及处理要求如下： （1）数据结构和与语法分析程序的接口请自行定义；类别码需按下表格式统一定义； （2）为了...
编译原理-词法分析C++
12-26
编译原理是研究编译器设计的一门学科，其中词法分析是编译器的第一个阶段，对于理解程序的结构和含义至关重要。在这个主题中，我们将深入探讨“编译原理”中的“词法分析”部分，特别是针对C++编程语言。 词法分析...
编译原理-词法分析器
01-12
在编程领域，编译原理是理解计算机语言处理过程的关键部分，而词法分析器则是编译器的第一步。本文将深入探讨编译原理中的词法分析器，以及如何使用Python实现一个简单的词法分析器来构建一个表达式计算器。 首先，...
编译原理-词法分析实验（javascript+html）实现编译原理可视化（含报告）
06-01
编译原理-词法分析实验...通过设计一个词法分析程序，对词法进行分析，加强对词法的理解，掌握对程序设计语言的分解和理解。 本实验雷同可能性少，并且采用可视化展示的方法，很直观可以看出编译原理词法分析的细节
UESTC-编译原理-词法分析器-语法分析器.zip
最新发布
06-02
《UESTC编译原理：词法分析器与语法分析器》 在计算机科学领域，编译原理是理解和构建编译器的关键学科。本资源“UESTC-编译原理-词法分析器-语法分析器.zip”是成都电子科技大学（UESTC）的一份课程设计或课程作业...
C++ 编译原理-词法分析程序
06-25
编写TPL语言的词法分析程序，它从左到右逐个字符地对源程序进行扫描，分离出一个个单词，存放到数组或链表等存储结构中，作为语法分析的输入。要求实现编译器的以下功能： (1) 能对任何TPL语言源程序进行分析。 (2) ...
编译原理实验报告-词法分析
01-14
《编译原理实验报告-词法分析》 在编译领域，词法分析是构建编译器的关键步骤之一，它负责将源代码分解成一个个独立的、有意义的符号，即“单词”或“记号”。本实验的目标在于帮助学生深入理解词法分析在编译程序...
编译原理 词法分析（两种简单的词法分析程序）
nyist_yangguang的博客
03-09 2399
第一种，是输入到黑窗口的，供程序读入，‘#’ 结束读入，开始词法分析 //头文件 #include <iostream> #include <map> #include <algorithm> #include <string> #include<stdio.h> #include<time.h> using namespace std; string instr;//输入符号串 int index;//当前输入符号读入字符的位置
编译原理-词法分析.zip
04-02
《编译原理》课程实验-词法分析： 实验目的：设计、编制并调试一个自定义语言C--的词法分析程序，加深对词法分析原理的理解。 实现功能：输入：所给文法的源程序字符串；输出：二元组（编码，值）构成的序列。（能...
编译原理-词法分析器-实验报告.pdf
05-06
编译原理-词法分析器实验报告 在编译原理中，词法分析器是编译器的第一个阶段，其目的是将源代码分割成一个个的单词，称为记号，并对其进行分类和分析。该实验报告主要介绍了设计、编制、调试一个词法分析器的过程...
利用c++编译原理----词法分析器
05-08
词法分析器是编译器中的一个重要组成部分，也是编译器的第一步。它的主要任务是将源代码中的字符流转换为有意义的单词流，也就是将源代码转换为一系列的词法单元。在C++中，词法分析器使用正则表达式来定义各种词法单元，例如标识符、关键字、运算符、常量等等。 在C++中，词法分析器通常采用有限自动机（DFA）来实现。DFA是一种状态机，它可以接受一个有限的输入字符序列并产生一个有限的输出序列。通过定义各种状态和状态之间的转移规则，DFA可以根据输入字符流自动地进行状态转移，最终生成词法单元序列。 在编写词法分析器时，需要注意一些细节问题，例如如何处理注释、如何处理字符串常量、如何处理数字常量等等。此外，还需要考虑如何处理错误输入和错误单词等异常情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值