Java 实现《编译原理》简单词法分析功能 - 程序解析

简易词法分析功能

要求及功能

（1）读取一个 txt 程序文件（最后的 # 作为结束标志，不可省去）

  1. {
  2.   int a, b;
  3.   a = 10;
  4.   if(a>=1){
  5.     b = a + 20;
  6.   }
  7. }
  8. #

（2）词法识别分析表

单词类别 单词自身值 内部编码
关键字 int、for、while、do、return、break、continue 1
标识符 除关键字外的以字母开头，后跟字母、数字的字符序列 2
常数 无符号整型数 3
运算符 +、-、*、/、>、<、=、>=、<=、!= 4
界限符 ,、;、{、}、(、) 5
换行符 \n 6

（3）输出结果：

  1. (5,{)
  2. (6,\n)
  3. (1,int)
  4. (2,a)
  5. (5,,)
  6. (2,b)
  7. (5,;)
  8. (6,\n)
  9. (2,a)
  10. (4,=)
  11. (3,10)
  12. (5,;)
  13. (6,\n)
  14. (2,if)
  15. (5,()
  16. (2,a)
  17. (4,>=)
  18. (3,1)
  19. (5,))
  20. (5,{)
  21. (6,\n)
  22. (2,b)
  23. (4,=)
  24. (2,a)
  25. (4,+)
  26. (3,20)
  27. (5,;)
  28. (6,\n)
  29. (5,})
  30. (6,\n)
  31. (5,})
  32. (6,\n)
  33. (0,#)

并保存成新的 txt 文件

编程实现

（1）程序文件目录：

（2）Word.java 文件：

  1. package com.java997.analyzer.lexical;
  3. /**
  4.  * <p>
  5.  * 表示识别后的词实体类
  6.  *
  7.  * @author XiaoPengwei
  8.  * @since 2019-06-13
  9.  */
  10. public class Word {
  12.     /**
  13.      * 种别码
  14.      */
  15.     private int typeNum;
  17.     /**
  18.      * 扫描得到的词
  19.      */
  20.     private String word;
  22.     public int getTypeNum() {
  23.         return typeNum;
  24.     }
  26.     public void setTypeNum(int typeNum) {
  27.         this.typeNum = typeNum;
  28.     }
  30.     public String getWord() {
  31.         return word;
  32.     }
  34.     public void setWord(String word) {
  35.         this.word = word;
  36.     }
  37. }

（3）CodeScanner.java 文件：

  1. package com.java997.analyzer.lexical;
  3. /**
  4.  * <p>
  5.  * 字符扫描
  6.  *
  7.  * @author XiaoPengwei
  8.  * @since 2019-06-13
  9.  */
  10. public class CodeScanner {
  12.     private static String _KEY_WORD_END = "end string of string";
  13.     private int charNum = 0;
  14.     private Word word;
  16.     private char[] input = new char[255];
  17.     private char[] token = new char[255];
  18.     private int p_input = 0;
  19.     private int p_token = 0;
  21.     private char ch;
  23.     /**
  24.      * 关键字数组
  25.      */
  26.     private String[] rwtab = {"int", "if", "while", "do", "return", "break", "continue", _KEY_WORD_END};
  28.     /**
  29.      * 逻辑运算数组
  30.      */
  31.     private String[] logicTab = {"==",">=","<=","!=", _KEY_WORD_END};
  33.     public CodeScanner(char[] input) {
  34.         this.input = input;
  35.     }
  37.     /**
  38.      * 取下一个字符
  39.      *
  40.      * @return
  41.      */
  42.     public char m_getch() {
  43.         if (p_input < input.length) {
  44.             ch = input[p_input];
  45.             p_input++;
  46.         }
  47.         return ch;
  48.     }
  50.     /**
  51.      * 如果是标识符或者空白符就取下一个字符
  52.      */
  53.     public void getbc() {
  54.         while ((ch == ' ' || ch == '\t') && p_input < input.length) {
  55.             ch = input[p_input];
  56.             p_input++;
  57.         }
  58.     }
  60.     /**
  61.      * 把当前字符和原有字符串连接
  62.      */
  63.     public void concat() {
  64.         token[p_token] = ch;
  65.         p_token++;
  66.         token[p_token] = '\0';
  67.     }
  69.     /**
  70.      * 回退一个字符
  71.      */
  72.     public void retract() {
  73.         p_input--;
  74.     }
  76.     /**
  77.      * 判断是否为字母
  78.      *
  79.      * @return boolean
  80.      * @author XiaoPengwei
  81.      */
  82.     public boolean isLetter() {
  83.         return ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z';
  84.     }
  86.     /**
  87.      * 判断是否为数字
  88.      *
  89.      * @return boolean
  90.      * @author XiaoPengwei
  91.      */
  92.     public boolean isDigit() {
  93.         return ch >= '0' && ch <= '9';
  94.     }
  96.     /**
  97.      * 查看 token 中的字符串是否是关键字，是的话返回关键字种别编码，否则返回 2
  98.      *
  99.      * @return
  100.      */
  101.     public int isKey() {
  102.         int i = 0;
  103.         while (rwtab[i].compareTo(_KEY_WORD_END) != 0) {
  104.             if (rwtab[i].compareTo(new String(token).trim()) == 0) {
  105.                 return i + 1;
  106.             }
  107.             i++;
  108.         }
  109.         return 2;
  110.     }
  112.     /**
  113.      * 可能是逻辑预算字符
  114.      *
  115.      * @return
  116.      */
  117.     public Boolean isLogicChar() {
  118.         return ch == '>' || ch == '<'|| ch == '='|| ch == '!';
  119.     }
  121.     /**
  122.      * 查看 token 中的字符串是否是逻辑运算符，是的话返回关键字种别编码，否则返回 2
  123.      *
  124.      * @return
  125.      */
  126.     public int isLogicTab() {
  127.         int i = 0;
  128.         while (logicTab[i].compareTo(_KEY_WORD_END) != 0) {
  129.             if (logicTab[i].compareTo(new String(token).trim()) == 0) {
  130.                 return i + 1;
  131.             }
  132.             i++;
  133.         }
  134.         return 4;
  135.     }
  137.     /**
  138.      * 能够识别换行，单行注释和多行注释的
  139.      * 换行的种别码设置成30
  140.      * 多行注释的种别码设置成31
  141.      *
  142.      * @return
  143.      */
  144.     public Word scan() {
  145.         token = new char[255];
  146.         Word myWord = new Word();
  147.         myWord.setTypeNum(10);
  148.         myWord.setWord("");
  150.         p_token = 0;
  151.         m_getch();
  152.         getbc();
  153.         if (isLetter()) {
  154.             while (isLetter() || isDigit()) {
  155.                 concat();
  156.                 m_getch();
  157.             }
  158.             retract();
  159.             myWord.setTypeNum(isKey());
  160.             myWord.setWord(new String(token).trim());
  161.             return myWord;
  162.         } else if (isLogicChar()) {
  163.             while (isLogicChar()) {
  164.                 concat();
  165.                 m_getch();
  166.             }
  167.             retract();
  168.             myWord.setTypeNum(4);
  169.             myWord.setWord(new String(token).trim());
  170.             return myWord;
  171.         } else if (isDigit()) {
  172.             while (isDigit()) {
  173.                 concat();
  174.                 m_getch();
  175.             }
  176.             retract();
  177.             myWord.setTypeNum(3);
  178.             myWord.setWord(new String(token).trim());
  179.             return myWord;
  180.         } else {
  181.             switch (ch) {
  182.                 //5
  183.                 case ',':
  184.                     myWord.setTypeNum(5);
  185.                     myWord.setWord(",");
  186.                     return myWord;
  187.                 case ';':
  188.                     myWord.setTypeNum(5);
  189.                     myWord.setWord(";");
  190.                     return myWord;
  191.                 case '{':
  192.                     myWord.setTypeNum(5);
  193.                     myWord.setWord("{");
  194.                     return myWord;
  195.                 case '}':
  196.                     myWord.setTypeNum(5);
  197.                     myWord.setWord("}");
  198.                     return myWord;
  199.                 case '(':
  200.                     myWord.setTypeNum(5);
  201.                     myWord.setWord("(");
  202.                     return myWord;
  203.                 case ')':
  204.                     myWord.setTypeNum(5);
  205.                     myWord.setWord(")");
  206.                     return myWord;
  207.                 //4
  208.                 case '=':
  209.                     myWord.setTypeNum(4);
  210.                     myWord.setWord("=");
  211.                     return myWord;
  212.                 case '+':
  213.                     myWord.setTypeNum(4);
  214.                     myWord.setWord("+");
  215.                     return myWord;
  216.                 case '-':
  217.                     myWord.setTypeNum(4);
  218.                     myWord.setWord("-");
  219.                     return myWord;
  220.                 case '*':
  221.                     myWord.setTypeNum(4);
  222.                     myWord.setWord("*");
  223.                     return myWord;
  224.                 case '/':
  225.                     myWord.setTypeNum(4);
  226.                     myWord.setWord("/");
  227.                     return myWord;
  229.                 case '\n':
  230.                     myWord.setTypeNum(6);
  231.                     myWord.setWord("\\n");
  232.                     return myWord;
  233.                 case '#':
  234.                     myWord.setTypeNum(0);
  235.                     myWord.setWord("#");
  236.                     return myWord;
  237.                 default:
  238.                     concat();
  239.                     myWord.setTypeNum(-1);
  240.                     myWord.setWord("ERROR INFO: WORD = \"" + new String(token).trim() + "\"");
  241.                     return myWord;
  242.             }
  243.         }
  244.     }
  245. }

（4）MainAnalyzer.java 文件：

  1. package com.java997.analyzer.lexical;
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileWriter;
  6. import java.io.IOException;
  7. import java.io.Writer;
  8. import java.util.ArrayList;
  9. import java.util.Scanner;
  11. /**
  12.  * <p>
  13.  * 执行主程序
  14.  *
  15.  * @author XiaoPengwei
  16.  * @since 2019-06-13
  17.  */
  18. public class MainAnalyzer {
  19.     private File inputFile;
  20.     private File outputFile;
  21.     private String fileContent;
  22.     private ArrayList<Word> list = new ArrayList<>();
  24.     /**
  25.      * 构造方法
  26.      *
  27.      * @param input
  28.      * @param output
  29.      * @author XiaoPengwei
  30.      */
  31.     public MainAnalyzer(String input, String output) {
  32.         //实例化输入文件
  33.         inputFile = new File(input);
  35.         //实例化输出文件
  36.         outputFile = new File(output);
  37.     }
  39.     /**
  40.      * 从指定的 txt 文件中读取源程序文件内容
  41.      *
  42.      * @return java.lang.String
  43.      */
  44.     public String getContent() {
  45.         StringBuilder stringBuilder = new StringBuilder();
  46.         try (Scanner reader = new Scanner(inputFile)) {
  47.             while (reader.hasNextLine()) {
  48.                 String line = reader.nextLine();
  49.                 stringBuilder.append(line + "\n");
  50.                 System.out.println(line);
  51.             }
  52.             System.out.println("Successful reading of files：" + inputFile.getName());
  53.         } catch (FileNotFoundException e) {
  54.             e.printStackTrace();
  55.         }
  56.         return fileContent = stringBuilder.toString();
  57.     }
  59.     /**
  60.      * 然后扫描程序，在程序结束前将扫描到的词添加到 list 中
  61.      * 最后把扫描结果保存到指定的文件中
  62.      *
  63.      * @param fileContent
  64.      * @return void
  65.      */
  66.     public void analyze(String fileContent) {
  67.         int over = 1;
  68.         Word word = new Word();
  70.         //调用扫描程序
  71.         CodeScanner scanner = new CodeScanner(fileContent.toCharArray());
  72.         System.out.println("The result:");
  73.         while (over != 0) {
  74.             word = scanner.scan();
  75.             System.out.println("(" + word.getTypeNum() + "," + word.getWord() + ")");
  76.             list.add(word);
  77.             over = word.getTypeNum();
  78.         }
  79.         saveResult();
  80.     }
  82.     /**
  83.      * 将结果写入到到指定文件中
  84.      * 如果文件不存在，则创建一个新的文件
  85.      * 用一个 foreach 循环将 list 中的项变成字符串写入到文件中
  86.      */
  87.     public void saveResult() {
  89.         //创建文件
  90.         if (!outputFile.exists()) {
  91.             try {
  92.                 outputFile.createNewFile();
  93.             } catch (IOException e1) {
  94.                 e1.printStackTrace();
  95.             }
  96.         }
  98.         //写入文件
  99.         try (Writer writer = new FileWriter(outputFile)) {
  100.             for (Word word : list) {
  101.                 writer.write("(" + word.getTypeNum() + " ," + word.getWord() + ")\n");
  102.             }
  103.         } catch (IOException e) {
  104.             e.printStackTrace();
  105.         }
  106.     }
  108.     public static void main(String[] args) {
  110.         //注意输入文件路径/名称必须对, 输出文件可以由程序创建
  111.         MainAnalyzer analyzer = new MainAnalyzer("D:\\analyzer\\src\\main\\java\\com\\java997\\analyzer\\lexical\\input.txt", "D:\\analyzer\\src\\main\\java\\com\\java997\\analyzer\\lexical\\output.txt");
  113.         analyzer.analyze(analyzer.getContent());
  114.     }
  115. }

（5）input.txt 文件：

  1. {
  2.   int a, b;
  3.   a = 10;
  4.   if(a>=1){
  5.     b = a + 20;
  6.   }
  7. }
  8. #

执行测试

Java 实现《编译原理》简单词法分析功能 - 程序解析的更多相关文章

  1. Java的编译原理

    概述 java语言的"编译期"分为前端编译和后端编译两个阶段.前端编译是指把*.java文件转变成*.class文件的过程; 后端编译(JIT, Just In Time Comp ...

  2. 深入分析Java的编译原理

    在<Java代码的编译与反编译>中,有过关于Java语言的编译和反编译的介绍.我们可以通过javac命令将Java程序的源代码编译成Java字节码,即我们常说的class文件.这是我们通常 ...

  3. 编译原理简单语法分析器（first,follow,分析表）源码下载

    编译原理(简单语法分析器下载) http://files.cnblogs.com/files/hujunzheng/%E5%8A%A0%E5%85%A5%E5%90%8C%E6%AD%A5%E7%AC ...

  4. .Net编译原理简单介绍

    首先简单说一下计算机软件运行.所谓软件运行,就是一步一步做一些事情.计算机只认识0和1.给计算机下命令,只能是0与1的方式,确切的说,其实是CPU只认识0和1,因为软件运行是CPU控制的.人直接操作0 ...

  5. Java网络编程以及简单的聊天程序

    网络编程技术是互联网技术中的主流编程技术之一,懂的一些基本的操作是非常必要的.这章主要讲解网络编程,UDP和Socket编程,以及使用Socket做一个简单的聊天软件. 全部代码下载:链接 1.网络编 ...

  6. Net编译原理简单

    转载:http://blog.csdn.net/sundacheng1989/article/details/20941893 首先简单说一下计算机软件运行.所谓软件运行,就是一步一步做一些事情.计算 ...

  7. Java continue break 制作简单聊天室程序，屏蔽不文明语言，显示每句话聊天时间 for(;;) SimpleDateFormat("yyyy-MM-dd hh:mm:ss") equalsIgnoreCase

    package com.swift; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanne ...

  8. Java注解及其原理以及分析spring注解解析源码

    注解的定义 注解是那些插入到源代码中,使用其他工具可以对其进行处理的标签. 注解不会改变程序的编译方式:Java编译器对于包含注解和不包含注解的代码会生成相同的虚拟机指令. 在Java中,注解是被当做 ...

  9. Java中JSON的简单使用与前端解析

    http://www.blogjava.net/qileilove/archive/2014/06/13/414694.html 一.JSON JSON(JavaScript Object Notat ...

随机推荐

  1. debain安装文泉驿字体

    sudo apt-get install ttf-wqy-microhei sudo apt-get install ttf-wqy-zenhei

  2. python爬虫前提技术

    1.BeautifulSoup 解析html如何使用 转自:http://blog.csdn.net/u013372487/article/details/51734047 #!/usr/bin/py ...

  3. 联想H430怎么清除cmos密码?

    联想H430怎么清除cmos密码? 方法一:长时间对cmos放电 首先断掉主机电源,然后找到主板上的纽扣电池,将电池小心取出,然后使用一金属导体,短接电池座中的正负极,这样也可达到快速放电的目的. 有 ...

  4. python基础之元祖tuple

    元祖是只读列表,不可哈希,可循环查询,可切片*儿子不能改,孙子可更改--元祖里面单个元素不能更改---元祖内列表可更改增:tu1+tu2查:tu1[index] tu1[start_index:end ...

  5. Kali Linux 2019.2安装谷歌输入法

    前言 Linux下常用的中文输入法平台有IBus.fcitx和scim.scim现在维护滞后,不推荐使用. IBus ("Intelligent Input Bus") 是一个 输 ...

  6. 3 基于梯度的攻击——MIM

    MIM攻击原论文地址——https://arxiv.org/pdf/1710.06081.pdf 1.MIM攻击的原理 MIM攻击全称是 Momentum Iterative Method,其实这也是 ...

  7. Python 输入IP地址及掩码告诉你该网段包含的全部地址(IPy模块练习)

    IPy模块原本使用时需要输入正确的网络位和掩码,我利用处理报错的机制实现了输入任意IP地址和掩码均可正确输出结果的小程序. #!/usr/bin/env python # -*- coding: ut ...

  8. python打印带颜色的字体

    在python开发的过程中,经常会遇到需要打印各种信息.海量的信息堆砌在控制台中,就会导致信息都混在一起,降低了重要信息的可读性.这时候,如果能给重要的信息加上字体颜色,那么就会更加方便用户阅读了. ...

  9. 怎么快速写好看的手机menu菜单

    要达到这样的效果: <div class="menu"> <div class="menu-1"> <img alt=" ...

  10. 福建工程学院第十四届ACM校赛B题题解

    第二集,未来的我发量这么捉急的吗 题意: 有n个数,请问有多少对数字(i,j)(1<=i<j<=n),满足(a[i]^a[j])+((a[i]&a[j])<<1) ...