编译原理-词法分析器的java实现

最新推荐文章于 2024-08-02 10:02:30 发布
最新推荐文章于 2024-08-02 10:02:30 发布
阅读量3.7k 收藏 37
点赞数 4
文章标签： 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Simple__Code/article/details/108397124
版权

编译原理-词法分析器的java实现

实验步骤

编程环境

eclipse开发软件

实验步骤

1. 构建DFA

状态转换图

流程图

流程图

3. 代码实现分析

  1. 给标识符、常量等给定一个标识符
  2. 给定一个字符串，将字符串转换为字符数组
  3. 判断当前读入的字符是什么字符
  4. 根据DFA来判断和输出

4.编号规定

001:加法运算符 +
002:减法运算符 -
003:乘法运算符 *
004:除法运算符 /
005:左括号 （
013:右括号 ）
008.标识符
010.整数
011.等号运算符 ==
012.浮点数
014:错误字段 error
015:赋值运算符 =
016：大于号 >
017：小于号 <
018：不等于号 !=
019：小于等于号 <=
020：大于等于号 >=
021:{ 左中括号 {
022:} 右中括号 }
023: ; 分号 ;

import java.util.*;

/*
编号规定:
001:加法运算符
002:减法运算符
003:乘法运算符
004:除法运算符
005:左括号
013:右括号	
008.标识符
010.整数
011.等号运算符
012.浮点数
014:错误字段
015:赋值运算符
016：大于号
017：小于号 
018：不等于号
019：小于等于号
020：大于等于号
021:{ 左中括号
022:} 右中括号
023: ;	分号
*/
public class lexicalAnalysis {
    private static char[] Code;//转化为字符数组
    public static ArrayList<String> tokens=new ArrayList<>();//用于之后的语法分析传值使用

    public static void main(String[] args) { 
//        String s = "public static void main(String[] args) { 
//      String s = "abc2@e=num2+12.3.23)*123-12.#;#";//输入符号串
//        String s = "public static void main(String[] args) { \r\n" + 
//        		"        String s = \"abc2@e=num2+12.3.23)*123-12.#\";#";//表达式为A1=1.2+3*(4-6/3)
    	String s = "vhguiyv7=-okllpl,-=popl'>=><==#";
    	
        StartLexicalAnalysis(s);
    }

    public static void StartLexicalAnalysis(String s) {//开始进行语法分析
        if (IsCode(s)) {//判断
        	tokens.add("begin") ;
        System.out.println("当前输入符号为：" + s.substring(0,s.length()-1));
        System.out.println("词法分析结果如下：");
        StartState(0, 0);
        }
    }
    private static boolean IsCode(String s){//判断源代码是否为空，为空则不能进行词法分析
        if (s.isEmpty()||s.toCharArray()[0]=='#') {
            System.out.println("源代码为空，无法进行词法分析！");
            return false;
        }
        else {
            Code = s.toCharArray();
            return true;
        }

    }

    private static void StartState(int basicPointer, int currentPointer)//状态0，初始状态
    {

        if (Code[currentPointer] == '#') {
            System.out.println("词法分析结束");
            tokens.add("end") ;
        }
        else if (IsEqual(Code[currentPointer]))//如果当前字符是等于号进入EqualState
        {
            EqualState(currentPointer,basicPointer);
        }
        else if (IsAdd(Code[currentPointer]))//如果当前字符是加号进入AddState
        {
            AddState(currentPointer);
        }
        else if (IsSub(Code[currentPointer]))//如果当前字符是减号进入SubState
        {
            SubState(currentPointer);
        }
        else if (IsMul(Code[currentPointer]))//如果当前字符是乘号进入MulState
        {
            MulState(currentPointer);
        }
        else if (IsDiv(Code[currentPointer]))//如果当前字符是除号进入DivState
        {
            DivState(currentPointer);
        }
        else if (IsLParent(Code[currentPointer]))//如果当前字符是左括号进入LParentState
        {
            LParentState(currentPointer);
        }
        else if (IsRParent(Code[currentPointer]))//如果当前字符是右括号进入RParentState
        {
            RParentState(currentPointer);
        }

        else if (IsAlpha(Code[currentPointer]))//如果当前字符是字母号进入IdentState
        {
            IdentState(basicPointer, currentPointer + 1);//是字母就进入状态6
        }
        else if (IsDigit(Code[currentPointer]))//如果当前字符是数字进入IntState
        {
            IntState(basicPointer, currentPointer + 1);//是数字就进入状态7
        }
        else if ( IsGreater(Code[currentPointer]) ) 
        { //如果当前字符是大于号
			GreaterState(basicPointer, currentPointer + 1);
		}
        else if ( IsLess(Code[currentPointer]) )
        { //如果当前字符是小于号
			LessState(basicPointer, currentPointer + 1);
		}
        else if ( IsExc(Code[currentPointer]) )
        { //如果当前字符是！
			ExcState(basicPointer, currentPointer + 1);
		}
        else if ( IsLZKH(Code[currentPointer]) )
        { //如果当前字符是{
        	LZKHState(basicPointer, currentPointer);
		}
        else if ( IsRZKH(Code[currentPointer]) )
        { //如果当前字符是}
        	RZKHState(basicPointer, currentPointer);
		}
        else if ( IsFH(Code[currentPointer]) )
        { //如果当前字符是;
        	FHState(basicPointer, currentPointer);
		}
        else {

            System.out.println("(014,错误," + Code[currentPointer] + ")");
            String tempSt="014,"+Code[currentPointer];
            tokens.add(tempSt);
            StartState(basicPointer + 1, currentPointer + 1);
        }
    }

    
    private static void FHState(int basicPointer, int j) {
    	System.out.println("(023，分号，" + Code[j] + ")");
        String tempSt="023,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
	}

	private static void RZKHState(int basicPointer, int j) {
		System.out.println("(022，右中括号，" + Code[j] + ")");
        String tempSt="022,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
	}

	private static void LZKHState(int basicPointer, int j) {
		System.out.println("(021，左中括号，" + Code[j] + ")");
        String tempSt="021,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
	}

	private static void ExcState(int basicPointer, int j) {
    	if ( Code[j] == '=' ) {
			ExcState(basicPointer,j+1);
		}else {
			if ( j - basicPointer == 2 ) {
				System.out.print("(018,不等于号,");
				String tempSt = "!" ;
				printA(basicPointer,j,tempSt);
			}else {
				System.out.print("(014,错误," );
	            String tempSt="014,";
	            printA(basicPointer,j,tempSt);
			} 
		}
	}
 
	private static void LessState(int basicPointer, int j) {
		if ( Code[j] == '=' ) {
			LessState(basicPointer,j+1);
		}else {
			if ( j - basicPointer == 2 ) {
				System.out.print("(019,小于等于号,");
				String tempSt = "<" ;
				printA(basicPointer,j,tempSt);
			}else if (j - basicPointer == 1) {
				System.out.print("017,小于号," + Code[j-1] + ")");
			    String tempSt="017,"+Code[j-1];
		        tokens.add(tempSt);
		        StartState(j + 1, j + 1);
			}
			else {
				System.out.print("(014,错误," );
	            String tempSt="014,";
	            printA(basicPointer,j,tempSt);
			} 
		}
	}

	private static void GreaterState(int basicPointer, int j) {
		if ( Code[j] == '=' ) {
			GreaterState(basicPointer,j+1);
		}else {
			if ( j - basicPointer == 2 ) {
				System.out.print("(020,大于等于号,");
				String tempSt = ">" ;
				printA(basicPointer,j,tempSt);
			}else if (j - basicPointer == 1) {
				System.out.println("(016,大于号," + Code[j-1] + ")");
			    String tempSt="016,"+Code[j-1];
		        tokens.add(tempSt);
		        StartState(j , j + 1);
			}
			else {
				System.out.print("(014,错误," );
	            String tempSt="014,";
	            printA(basicPointer,j,tempSt);
			} 
		}
	}

	private static void EqualState(int j, int basicPointer)//表示字符为等号运算符
    {  
    	if ( IsEqual(Code[ j+1 ]) ) {
			EqualState(j+1, basicPointer);
		}else {
			if ( j - basicPointer == 1 ) {
				System.out.print("(011，等于号，");
				String tempSt="011," ;
				printA(basicPointer,j+1,tempSt);
			}else if (j - basicPointer == 0) {
				//赋值运算符
				System.out.println("(015，赋值运算符，" + Code[j] + ")");
			    String tempSt="015,"+Code[j];
		        tokens.add(tempSt);
		        StartState(j + 1, j + 1);
			}else {
				//错误代码
				System.out.print("(014,错误," );
	            String tempSt="014,"; 
	            printA(basicPointer,j+1,tempSt); 
			}
		}
    	
//        System.out.println("(011，等于号，" + Code[j] + ")");
//        String tempSt="011,"+Code[j];
//        tokens.add(tempSt);
//        StartState(j + 1, j + 1);
    }

    private static void AddState(int j)//表示字符为加法运算符
    {
        System.out.println("(001，加号，" + Code[j] + ")");
        String tempSt="001,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void SubState(int j)//表示字符为减法运算符
    {
        System.out.println("(002，减号，" + Code[j] + ")");
        String tempSt="002,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void MulState(int j)//表示字符为乘法运算符
    {
        System.out.println("(003，乘号，" + Code[j] + ")");
        String tempSt="003,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void DivState(int j)//表示字符为除法运算符
    {
        System.out.println("(004，除号，" + Code[j] + ")");
        String tempSt="004,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void LParentState(int j)//字符为左括号
    {
        System.out.println("(005，左括号，" + Code[j] + ")");
        String tempSt="005,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void RParentState(int j)//字符为右括号
    {
        System.out.println("(013，右括号，" + Code[j] + ")");
        String tempSt="013,"+Code[j];
        tokens.add(tempSt);
        StartState(j + 1, j + 1);
    }

    private static void IdentState(int i, int j)//标识符
    {
        //Code[i]为准标识符的第一个字符，是个字母 ,而Code[j-1]是字母或数字
        if (IsDigit(Code[j]) || IsAlpha(Code[j]))
        //如果当前字符仍然为字母或数字则再次进入IdentState
        {
            IdentState(i, j + 1);
        } else//如果当前字符为非数字及字母字符，则表明Code[i]~Code[j-1]这一段是标识符
        {
            System.out.print("(008,标识符，");
            String tempSt="008,";
            printA(i, j, tempSt);
        }
    }

    private static void IntState(int i, int j)//状态7，准实数
    {
        //Code[i]为准实数的第一个字符，是个字母 ,而Code[j-1]是数字或小数点
        if (IsDigit(Code[j]))//如果当前字符仍然是数字，则再次进入IntState
        {
            IntState(i, j + 1);
        }
        if (Code[j] == '.')//如果当前字符是小数点，进入PointState
        {
            PointState(i, j + 1);
        }
        if ((Code[j] != '.') && !IsDigit(Code[j]))
        //如果当前字符既不为小数点也不是数字 ，则表明Code[i]~Code[j-1]这一段是个实数
        {
            System.out.print("(010,整数，");
            String tempSt="010,";
            printA(i, j, tempSt);
        }
    }

    private static void PointState(int i, int j)//整数后接个小数点的中间态
    {
        //Code[i]~Code[j-1]之中含有小数点
        if (!IsDigit(Code[j])) {//小数点后还是小数点或者不是数字时报错
            System.out.print("(014,错误，");
            String tempSt="014,";
            int q = i;//从Code[i]开始算起
            while ((IsDigit(Code[q])) || (Code[q]) == '.')
            //直接相连的数字或小数点都属于这个无效字段的一部分
            {
                tempSt=tempSt+Code[q];
                System.out.print(Code[q]);
                q++;
            }
            System.out.println(")");
            tokens.add(tempSt);
            //Code[q]此时为无效字段的下一个字符
            StartState(q, q);

        }
        if (IsDigit(Code[j]))//如果当前字符是数字，则进入FloatState
        {
            FloatState(i, j + 1);
        }
    }

    private  static void FloatState(int i,int j){

        if (IsDigit(Code[j]))//如果当前字符是数字，则再次进入FloatState
        {
            FloatState(i, j + 1);
        }
        if (!IsDigit(Code[j]))
        //如果当前字符是非数字字符，说明Code[i]~Code[j-1]这一段是浮点数
        {
            System.out.print("(012,浮点数，");
            String tempSt="012,";
            printA(i, j, tempSt);
        }
    }

    private static void printA(int i, int j, String tempSt) {//用于输出非单一字符
        for (int k = i; k < j; k++) {
            tempSt = tempSt + Code[k];
            System.out.print(Code[k]);
        }
        System.out.println(")");
        tokens.add(tempSt);
        StartState(j, j);
    }

    private static boolean IsEqual(char ch) {//判断是否是字符'='
        return ch == '=';
    }

    private static boolean IsAdd(char ch)//判断是否是字符'+'
    {
        return ch == '+';
    }

    private static boolean IsSub(char ch)//判断是否是字符'-'
    {
        return ch == '-';
    }

    private static boolean IsMul(char ch)//判断是否是字符'*'
    {
        return ch == '*';
    }

    private static boolean IsDiv(char ch)//判断是否是字符'/'
    {
        return ch == '/';
    }

    private static boolean IsLParent(char ch)//判断是否左括号
    {
        return ch == '(';
    }

    private static boolean IsRParent(char ch)//判断是否是有括号
    {
        return ch == ')';
    }

    private static boolean IsDigit(char ch) {//判断是否是数字
        return Character.isDigit(ch);
    }

    private static boolean IsAlpha(char ch) {//判断是否是字母
        return Character.isLetter(ch);
    }

	private static boolean IsExc(char ch) {
		return ch == '!';
	}

	private static boolean IsLess(char ch) {
		return ch == '<';
	}

	private static boolean IsGreater(char ch) {
		return ch == '>';
	}

	private static boolean IsFH(char ch) {
		return ch == ';';
	}

	private static boolean IsRZKH(char ch) {
		return ch == '}';
	}

	private static boolean IsLZKH(char ch) {
		return ch == '{';
	}
}

5.运行结果

在这里插入图片描述
在这里插入图片描述

源代码下载https://download.csdn.net/download/Simple__Code/12809398

夕卜
关注
  • 4
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现简单词法、语法分析器
编程小鹏的博客
06-08 261
语法分析器是编译器中的关键组件，用于检查源代码是否遵循编程语言的语法规则。词法分析器是编译器中的一个关键组件，用于将源代码解析成词法单元。
java实现词法分析器——编译原理实验
04-13
在这个实验中，我们将使用Java语言来实现一个词法分析器，它能够处理关键字、运算符、分界符、标识符、常数以及未识别的符号。 首先，词法分析器的核心任务是识别源代码中的各种元素。对于Java而言，关键字如`...
编译原理大作业-词法分析器、语法分析器源码（java实现）.zip
03-15
编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、语法分析器源码（java实现）.zip编译原理大作业-词法分析器、...
编译原理-词法分析（java）
06-25
在这个主题中，我们将重点探讨词法分析，特别是使用Java实现词法分析器的过程。 词法分析，又称扫描或Tokenization，是编译器的第一步。它的任务是从源代码中识别出一个个有意义的单元，称为“标记”（Token）。...
编译原理词法分析器及语法分析器实验报告，JAVA实现
06-26
在这个实验中，我们将使用Java语言实现一个词法分析器，并结合简单的语法分析。 首先，词法分析器需要识别并处理保留字。保留字是编程语言中具有特殊含义的词汇，例如实验中提到的`if`、`int`、`for`等，它们的单词...
编译原理实验词法分析器 java语言版
04-15
本实验是基于Java语言实现的一个词法分析器，主要关注对小数和科学记数法的识别。 首先，我们需要了解词法分析的基本概念。词法分析器（也称为扫描器或词法规则器）的任务是从源代码中读取字符流，并根据预定义的...
2023-2024年 Java开发岗面试题经验分享
A_aspectJ的博客
08-02 391
在各行各业中，面试前我们总会思索一个问题：究竟什么样的求职者能获得面试官的青睐？作为求职者，我们又该如何准备，以应对各种面试官的挑战？在这激烈的竞争里，如何才能让自己从众多应聘者中脱颖而出？本文就自己的面试和大家一块交流分享。
[毕业设计]VB环境下电脑销售与财务管理系统开发(ACCESS+源代码+论文).zip
08-05
[毕业设计]VB环境下电脑销售与财务管理系统开发(ACCESS+源代码+论文)
PPO（Proximal Policy Optimization，近端策略优化）算法
08-05
在解答2024年华数杯全国大学生数学建模竞赛的C题“老外游中国”时，虽然PPO（Proximal Policy Optimization，近端策略优化）算法主要是应用于强化学习领域，特别是在解决连续动作空间的策略优化问题上，但在此数学建模竞赛中，它并不直接适用于数据处理、综合评价或路径规划等任务。不过，我们可以从数据处理和决策优化的角度，类比强化学习中的一些思想来构思解题策略。 然而，对于本题而言，我们可以更侧重于数据分析、综合评价模型（如层次分析法AHP、TOPSIS、模糊综合评价等）和路径规划算法（如Dijkstra、A*、遗传算法等）来解决问题。以下是对各个问题的进一步建模思路： 一、问题1建模思路 1.1 数据处理与分析 数据收集与清洗：首先，需要加载所有352个城市的CSV文件，对每个城市的100个景点信息进行数据清洗，去除无效或缺失的关键信息（如评分缺失的景点）。 最高分查找：遍历所有景点，找到最高评分（BS），并统计获评该评分的景点数量。 城市排名：统计每个城市获评BS的景点数量，并根据数量多少进行排序，列出前10个城市。 二、问题2建模思路 2.1 综合评价体系构建
中国城市统计年鉴（1985-2023）
08-05
《中国城市统计年鉴》是全面反映中国城市社会经济发展情况的资料性年刊。《中国城市统计年鉴—2023》收录了2022年全国各级城市社会经济发展等方面的主要统计数据。 本年鉴内容共分四个部分: 第一部分是全国城市行政区划,列有不同区域、不同级别的城市分布情况; 第二、三部分分别是地级以上城市统计资料和县级城市统计资料,具体包括人口、资源环境、经济发展、科技创新、人民生活、公共服务、等方面的数据; 第四部分是附录,为主要统计指标解释。 需要说明的是,从1997年开始,地级以上城市和县级城市分别采用不同的统计制度,有些指标在两类城市之间不具有可比性,故本年鉴将地级以上城市和县级城市统计资料分为独立的两部分。本年鉴所涉及的全国或全部城市统计资料,均未包括香港特别行政区、澳门特别行政区和台湾省。
振中TP900 驱动工具2.2
08-05
振中TP900 驱动工具2.2
大学信息安全试题精选12
08-05
大学信息安全试题精选 【项目资源】：包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发、大数据、课程资源、音视频、网站开发等各种技术项目的源码。包括STM32、ESP8266、PHP、QT、Linux、iOS、C++、Java、python、web、C#、EDA、proteus、RTOS等项目的源码。 【项目质量】：所有源码都经过严格测试，可以直接运行。功能在确认正常工作后才上传。 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或热衷于研究的人来说，可以在这些基础代码上进行修改和扩展，实现其他功能。 【沟通交流】：有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。鼓励下载和使用，并欢迎大家互相学习，共同进步。
mutiple_pie (8).zip
08-05
mutiple_pie (8).zip
基于pytorch实现的ResUnet对BRATS脑肿瘤多模态分割项目（数据集、源码、训练结果）
最新发布
08-06
基于pytorch实现的ResUnet对BRATS脑肿瘤多模态分割项目（数据集、源码、训练结果） 本项目对BRATS脑肿瘤的四种模态FLAIR、T1w、t1gd、T2w进行融合分割 实现思路，将四种模态进行融合，并且将原始的nii.gz数据转换成npy数据。然后将四种模态的npy数据输入resUnet网络，总共训练了30个epoch，训练集的iou达到了0.84左右 如果想更换数据集进行多模态的训练，更换数据集按照readme文件操作即可
[毕业设计]JAVA大文件分块传输与合并机制(源代码+论文).zip
08-05
[毕业设计]JAVA大文件分块传输与合并机制(源代码+论文)
销售总数据统计表.xlsx
08-05
销售管理表，财务报表，占比分析，消费能力分析，日程安排，提成表，考核表 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
毕业设计:基于Springboot的智慧校园管理微信小程序论文
08-05
互联网发展至今，其理论与技术均已趋于成熟，并广泛渗透于社会的各个领域。它使得信息能够通过网络迅速传播，结合信息管理工具，可有效地服务于大众。针对高校教师成果信息管理存在的混乱、高错误率、信息安全性不足、劳动强度大及耗时费力等问题，智慧校园管理系统的应用能够实现更为科学和规范的信息管理。 该系统采用Java语言进行开发，利用MySQL数据库构建数据表以存储系统生成的数据。它不仅能够提供信息的展示与相应服务，还涵盖了智慧校园管理系统信息的全面管理功能，包括信息的查看与管理。 总而言之，智慧校园管理系统实现了信息的集中化管理，具有高度的保密性、高效率、大存储空间及低成本等多重优势。它有助于降低信息管理成本，推动信息管理的计算机化进程。
[毕业设计]VB.NET+Access班主任班级事务自动化管理系统(源代码+毕业设计论文+任务书+中文摘要+封面).zip
08-05
[毕业设计]VB.NET+Access班主任班级事务自动化管理系统(源代码+毕业设计论文+任务书+中文摘要+封面)
linux安全、Web安全、java web等安全思维脑图
08-05
linux安全 Web安全 java web 人工智能 区块链安全 移动安全 运维安全 等安全思维脑图
编译原理词法分析器java
06-21
编译原理中的词法分析器，也称为扫描器或lexical analyzer，是程序语言处理的第一步，它的任务是将源代码分割成一系列有意义的符号，这些符号被称为tokens。在Java中，词法分析器通常用Java编写，因为Java提供了一套...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值