【编译原理】词法分析器&语法分析器

最新推荐文章于 2024-09-27 14:19:28 发布
最新推荐文章于 2024-09-27 14:19:28 发布
阅读量2.7k 收藏 37
点赞数 2
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Joise_/article/details/125637054
版权

简单编译器设计

采用Java语言对C++语言进行编译，具体的简单编译器设计

词法分析器-扫描器的设计与实现

基本符号表

在这里插入图片描述

状态转换图

在这里插入图片描述

代码实现


import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class LexicalAnalyzer {
    /**
     * 1表示标识符
     * 2表示常数
     * 3-9表示界符
     * 10-40表示关键字
     * 41-59表示运算符
     * 60表示字符串
     * */
    //关键字
    static String []keyWord={"class","new","static","break","continue","return","do","while","if","else","for","switch","case","default","char","double","float","int","long","short", "string","null","true","false","void","this","goto","endl","cout","cin","main"};
    //运算符
    static String []operation={"+","-","*","-=","*=","/=","<<",">>","==","!=",">","<","=",">=","<=","&&","||","!","."};
    //界符
    static String []symbol={",",";",":","(",")","{","}"};
    //标识符
    public ArrayList<String> identifer=new ArrayList<>();

    public ArrayList<String> keyWords=new ArrayList<>();
    public ArrayList<String> operations=new ArrayList<>();
    public ArrayList<String> symbols=new ArrayList<>();
    //指向当前所读到字符串的位置的指针
    public int p,lines;


    public static void main(String[] args) throws IOException {
        PrintStream oldPrintStream = System.out; //将原来的System.out交给printStream 对象保存
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        System.setOut(new PrintStream(bos)); //设置新的out

        LexicalAnalyzer lexicalAnalyzer = new LexicalAnalyzer();
        lexicalAnalyzer.init();
        File file = new File("C:\\Users\\28362\\Desktop\\收集箱\\编译原理\\put.txt");
        lexicalAnalyzer.lines=1;
        try(Scanner input=new Scanner(file)) {
            while (input.hasNextLine()){
                String str=input.nextLine();
                lexicalAnalyzer.analyze(str);
                lexicalAnalyzer.lines++;
            }
        }
        System.setOut(oldPrintStream);
        System.out.println(bos.toString());
        saveAsFile(bos.toString());
    }

    public void init()
    {
        Collections.addAll(keyWords, keyWord);
        Collections.addAll(operations, operation);
        Collections.addAll(symbols, symbol);
    }

    public void analyze(String str){
        p=0;
        char ch;
        str=str.trim();
        for (;p<str.length();p++){
            ch=str.charAt(p);
            if (Character.isDigit(ch)){
                digitCheck(str);
            }else if (Character.isLetter(ch)||ch=='_'){
                letterCheck(str);
            }
            else if (ch=='"'){
                stringCheck(str);
            }
            else if (ch==' '){
                continue;
            }else {
                symbolCheck(str);
            }
        }
    }

    /**
     * 数字的识别
     * 1、识别退出：
     *   1.1、遇到空格符
     *   1.2、遇到运算符或者界符
     * 2、错误情况：
     *   2.1、两个及以上小数点
     *   2.2、掺杂字母
     **/
    public void digitCheck(String str){
        String token= String.valueOf(str.charAt(p++));
        //判断数字的小数点是否有且是否大于1
        int flag=0;
        boolean err=false;
        char ch;
        for (;p<str.length();p++) {
            ch = str.charAt(p);
            if (ch==' '||(!Character.isLetterOrDigit(ch)&&ch!='.')) {
                break;
            }else if (err){
                token+=ch;
            }
            else {
                token+=ch;
                if (ch == '.') {
                    if (flag == 1) {
                        err = true;
                    } else {
                        flag++;
                    }
                }else if (Character.isLetter(ch)){
                    err=true;
                }
            }
        }
        if (token.charAt(token.length()-1)=='.'){
            err=true;
        }
        if (err){
            System.out.println(lines+"line"+": "+token+" is wrong");
        }else {
//            System.out.println("<"+2+", "+Integer.toBinaryString(Integer.parseInt(token))+">");
            System.out.println(2+", "+Integer.toBinaryString(Integer.parseInt(token)));
        }
        if (p!=str.length()-1||(p==str.length()-1&&!Character.isDigit(str.charAt(p)))){
            p--;
        }
    }

    /**
     * 标识符，关键字的识别
     * 识别退出：
     *      字符不为字母 数字 下划线
     * 识别：字符串是否存在关键字里 不为关键字则为标识符
     * */
    public void letterCheck(String str){
        String token= String.valueOf(str.charAt(p++));
        int num;
        char ch;
        for (;p<str.length();p++){
            ch=str.charAt(p);
            //isLetterOrDigit 确定指定的字符是否为字母或数字
            if (!Character.isLetterOrDigit(ch)&&ch!='_'){
                break;
            }else{
                token+=ch;
            }
        }
        if (keyWords.contains(token)){
            num = keyWords.indexOf(token)+10;
//            System.out.println("<"+num+", "+token+">");
            System.out.println(num+", "+token);
        }else {
            if (!identifer.contains(token))
                identifer.add(token);
            //System.out.println("<"+1+", "+"identifer["+identifer.indexOf(token)+"]"+">");
            System.out.println(1+", "+"identifer["+identifer.indexOf(token)+"]");
        }
        if (p!=str.length()-1||(p==str.length()-1&&(!Character.isLetterOrDigit(str.charAt(p))&&str.charAt(p)!='_'))){
            p--;
        }
    }

    /**
     * 符号识别
     * 识别退出
     *   1、判断是否为界符
     *   2、双目运算符分开也为存在与运算符中
     *   3、单个字符为运算符 则往后继续识别添加一个字符
     */
    public void symbolCheck(String str){
        String token= String.valueOf(str.charAt(p++));
        char ch;
        int num;
        if (symbols.contains(token)){
            num = symbols.indexOf(token) + 3;
//            System.out.println("<"+num+", "+token+">");
            System.out.println(num+", "+token);
            p--;
        }else {
            if (operations.contains(token)){
                if (p<str.length()){
                    ch=str.charAt(p);
                    if (operations.contains(token+ch)){
                        token+=ch;
                        p++;
                        if (p<str.length()){
                            ch=str.charAt(p);
                            if (operations.contains(token+ch)){
                                token+=ch;
                                num = 41+operations.indexOf(token);
//                                System.out.println("<"+num+", "+token+">");
                                System.out.println(num+", "+token);
                            }else{
                                p--;
                                num = 41+operations.indexOf(token);
//                                System.out.println("<"+num+", "+token+">");
                                System.out.println(num+", "+token);
                            }
                        }else{
                            num = 41+operations.indexOf(token);
//                            System.out.println("<"+num+", "+token+">");
                            System.out.println(num+", "+token);
                        }
                    }else {
                        p--;
                        num = 41+operations.indexOf(token);
//                        System.out.println("<"+num+", "+token+">");
                        System.out.println(num+", "+token);
                    }
                }
            }else {
                p--;
                System.out.println(lines+"line"+": "+token+" is wrong");
            }
        }
    }

    /**
     * 字符串检查
     * 识别 “  ”
     */
    public void stringCheck(String str){
        String token= String.valueOf(str.charAt(p++));
        char ch;
        for (;p<str.length();p++){
            ch=str.charAt(p);
            token+=ch;
            if (ch=='"'){
                break;
            }
        }
        if (token.charAt(token.length()-1)!='"'){
            System.out.println(lines+"line"+": "+token+" is wrong");
        }else {
//            System.out.println("<"+60+","+token+">");
            System.out.println(60+","+"strings");
        }
    }

//    public void readLine() throws IOException{
//        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//        String str;
//        str = br.readLine();
//        System.out.println(str);
//    }

    public static void saveAsFile(String str)
    {
        String fileName = "C:\\Users\\28362\\Desktop\\收集箱\\编译原理\\out.txt";
        FileWriter fileWriter = null;
        try {
            fileWriter = new FileWriter(fileName);
            fileWriter.write(str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileWriter.flush();
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

语法分析器的设计与实现

文法产生式

S‘：程序（语句的组合）S：语句 Q：else语句 L：标识符表 E：表达式

X：条件表达式 R：比较运算符 id：标识符 num：常量

S' -> S S'|Ɛ

S -> A L;|A main(){S'}|id = E;| id(L); | if(X){S}Q|while(X){S}|Ɛ

A -> int|char|short|long|float|double

Q -> else{S}|Ɛ

L -> id| L,id

X -> ERE

R -> >|>=|<|<=|==|!=

E -> +T|-T|E+T|E-T

T -> F|T*F|T/F

F -> id|num|(E)

提取公共左因子

S' → S S'|Ɛ

S → A A'|id B|if(X){S}Q|while(X){S}|Ɛ

A'→L;|main(){S'}

A → int|char|shor|long|double

B → (L); | =E;

L → id | L , id

Q → else{S} | Ɛ

X → ERE

R → > | >= | < | <= | == | !=

E → +T | -T | T | EM

M → +T | -T

T → F | TN

N → *F |/F

F → id | num | (E)

消除左递归

S’ → S S’
S’ → Ɛ
S → A A'
S → id B
S → if(X){S}Q
S → while(X){S}
S → Ɛ
A'→L;
A'→main(){S'}
B → (L);
B → =E;
L → id L’
L’→ , id L’
L’→ Ɛ
Q → else{S}
Q → Ɛ
X → ERE
E → TE’
E → +TE’
E → -TE’
E’ → ME’
E’ → Ɛ
M → +T
M → -T
T → FT’
T’ → NT’
T’ → Ɛ
N → *F
N → /F
F → id
F → num
F → (E)
R → >
R → >=
R → <
R → <=
R → ==
R → !=
A → char
A → short
A → int
A → long
A → double

求FIRST集

First(S’)={ char , short , int , long , float , double , id , if , while , Ɛ }
First(S)={ char , short , int , long , float , double , id , if , while , Ɛ }
First(A')={ id, main}
First(A)={ char , short , int , long, float  , double }
First(L)={ id }
First(L’)={ ，, Ɛ }
First(Q)={ else , Ɛ }
First(X)={ + , - , id , num , ( }
First(R)={ > , >= , < , <= , != , == }
First(E)={ + , - , id , num , ( }
First(E’)={ + , - , Ɛ }
First(M)={ + , - }
First(T)={ id , num , ( }
First(T’)={ * , / , Ɛ }
First(N)={ * , / }
First(F)={ id , num , ( }

求FOLLOW集

Follow (S’)={ #, } }
Follow (S)={ # , } }
Follow(A)={ id, main}
Follow(A')={# , }}
Follow (L)={ # , ) , ; , } }
Follow (L’)={ # , ) , ; , } }
Follow (Q)={#, } }
Follow (X)={ ) }
Follow (R)={ + , - , id , num , ( }
Follow (E)={ ) , ; , > , >= , < , <= , != , == }
Follow (E’)={ ) , ; , > , >= , < , <= , != , == }
Follow (M)={ ) , ; , > , >= , < , <= , != , == , + , - }
Follow (T)={ ) , ; , > , >= , < , <= , != , == , + , - }
Follow (T’)={ ) , ; , > , >= , < , <= , != , == , + , - }
Follow (N)={ ) , ; , > , >= , < , <= , != , == , + , - , * , / }
Follow (F)={ ) , ; , > , >= , < , <= , != , == , + , - , * , / }

LL（1）预测分析表中的数字分别代表的产生式如下：

0：S → A A'
1：S → id B
2：S → if(X){P}Q
3：S → while(X){P}
4：S → Ɛ
5：B → (L);
6：B → =E;
7：L → id L’
8：L’→ ,id L’
9：L’→ Ɛ
10：Q → else{S}
11：Q → Ɛ
12：X → ERE
13：E → +TE’
14：E → -TE’
15：E → TE’
16：E’→ ME’
17：E’→ Ɛ
18：M → +T
19：M → -T
20：T → FT’
21：T’→ NT’
22：T’→ Ɛ
23：N → *F
24：N → /F
25：F → id
26：F → num
27：F → (E)
28：R → >
29：R → >=
30：R → <
31：R → <=
32：R → ==
33：R → !=
34：S’ → S S’
35：S’ → Ɛ
36：A → char
37：A → short
38：A → int
39：A → long
40：A → float
41：A → double
42:A'→main(){S'}
43:A'→L;
44:S → A A'

预测分析表

在这里插入图片描述

代码实现

package parser;

import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;

public class Parser {
    private static ArrayList<String> stack = new ArrayList<>(); // 当前栈
    private static ArrayList<Integer> reader = new ArrayList<>(); // 待读队列
    private static Production[] productions = new Production[45]; // 产生式数组
    private static HashMap<Integer, String> map_i2s; // 种别码Map，种别码为键，单词为值
    private static HashMap<String, Integer> map_s2i; // 种别码Map，单词为键，种别码为值

    public static void main(String[] args) {
        int stackTop = 1;
        int readerTop = 0;
        int index = 0; // 当前步骤数
        initMap(); // 初始化种别码Map
        initProductions(); // 产生式初始化
        stack.add(0, String.valueOf(map_s2i.get("#"))); // 在stack底部加上#
        stack.add(stackTop, "S'"); // 将S'压入栈
        System.out.print("请输入词法分析结果的文件路径：");
        Scanner scanner = new Scanner(System.in);
        String filepath = scanner.next();
        StringBuffer outputBuffer = new StringBuffer(); // 输出到文件的StringBuffer

        // 通过词法分析器的输出结果，初始化reader
        try {
            readToReader(filepath);
        } catch (IOException e) {
            e.printStackTrace();
        }

        reader.add(map_s2i.get("#")); // 在reader末尾加上#
        while (stackTop >= 0) {
            System.out.printf("%-6s", "第" + ++index + "步：");
            System.out.printf("%-10s", "当前栈：");
            outputBuffer.append("第" + index + "步： 当前栈：");
            StringBuffer sb = new StringBuffer(); // 引入StringBuffer仅为控制在控制台的输出格式对齐

            //获取当前栈的字符 用于显示
            for (int i = 0; i <= stackTop; i++) {
                String str = null;
                try {
                    str = map_i2s.get(Integer.valueOf(stack.get(i)));
                    if (str != null) {
                        sb.append(str + " ");
                        outputBuffer.append(str + " ");
                    }
                } catch (NumberFormatException e) {
                    sb.append(stack.get(i) + " ");
                    outputBuffer.append(stack.get(i) + " ");
                }
            }

            System.out.printf("%-30s", sb.toString());
            System.out.print("待读队列：");
            outputBuffer.append("        待读队列：");
            sb = new StringBuffer();

            //获取当前队列的字符 用于显示
            for (int i = 0; i < reader.size(); i++) {
                sb.append(map_i2s.get(reader.get(i)) + " ");
                outputBuffer.append(map_i2s.get(reader.get(i)) + " ");
            }
            System.out.printf("%-55s", sb.toString());

            //比较栈顶和队底的元素
            if (match(stackTop, readerTop)) {
                stackTop--;
                System.out.print("\n");
                outputBuffer.append("\n");
            } else {
                int i = ll1_table(stackTop, readerTop);
                stackTop += stackPush(stackTop, productions[i]); // 压栈
                System.out.printf("%-30s", "下一步所用产生式：" + productions[i].prod);
                System.out.println();
                outputBuffer.append("         下一步所用产生式：" + productions[i].prod + "\n");
            }
        }


        if (stackTop == -1) {
            System.out.println("语法分析成功");
            outputBuffer.append("Accept");
        }

        System.out.print("请输入语法分析结果文件的保存路径：");
        String outputPath = scanner.next();
        // 将StringBuffer的内容输出到文件
        File outputFile = new File(outputPath);
        if (outputFile.exists()) {
            outputFile.delete();
        }
        PrintWriter writer = null;
        try {
            outputFile.createNewFile();
            writer = new PrintWriter(new FileOutputStream(outputFile));
            writer.write(outputBuffer.toString());
        } catch (IOException e1) {
            e1.printStackTrace();
        } finally {
            if (writer != null) {
                writer.close();
            }
        }
    }

    /**
     * 读取文件内容，词法分析结果
     * @param filePath
     * @throws IOException
     */
    public static void readToReader(String filePath) throws IOException {
        InputStream is = new FileInputStream(filePath);
        String line; // 用来保存每行读取的内容
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        line = br.readLine(); // 读取第一行
        while (line != null) { // 如果 line 为空说明读完了
            int pos = line.indexOf(",");
            reader.add(Integer.valueOf(line.substring(0, pos)));
            line = br.readLine(); // 读取下一行
        }
        br.close();
        is.close();
    }

    /**
     * 压栈，将对应的文法产生式压入栈
     * @param stackTop
     * @param production
     * @return
     */
    private static int stackPush(int stackTop, Production production) {
        int len = production.r_str.length;
        stack.remove(stackTop);
        if ("ε".equals(production.r_str[0])) {
            }
        else {
            for (int i = len - 1; i >= 0; i--) {
                stack.add(production.r_str[i]);
            }
            return len - 1;
        }
        return -1;
    }

    /**
     * ll(1)预测分析表
     * 通过 栈顶的元素和读入的元素 返回对应的文法产生式
     * @param stackTop
     * @param readerTop
     * @return
     */
    private static int ll1_table(int stackTop, int readerTop) {
        if ("S".equals(stack.get(stackTop))) {
            if ("char".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("short".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("int".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("long".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("float".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("double".equals(map_i2s.get(reader.get(readerTop)))) {
                return 0;
            } else if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 1;
            } else if ("if".equals(map_i2s.get(reader.get(readerTop)))) {
                return 2;
            } else if ("while".equals(map_i2s.get(reader.get(readerTop)))) {
                return 3;
            } else if ("}".equals(map_i2s.get(reader.get(readerTop)))) {
                return 4;
            } else if ("#".equals(map_i2s.get(reader.get(readerTop)))) {
                return 4;
            } else {
                return -1;
            }
        } else if ("B".equals(stack.get(stackTop))) {
            if ("(".equals(map_i2s.get(reader.get(readerTop)))) {
                return 5;
            } else if ("=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 6;
            } else {
                return -1;
            }
        } else if ("L".equals(stack.get(stackTop))) {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 7;
            }
//            else if("main".equals(map_i2s.get(reader.get(readerTop))))
//            {
//                return 42;
//            }
            else {
                return -1;
            }
        } else if ("L'".equals(stack.get(stackTop))) {
            if (";".equals(map_i2s.get(reader.get(readerTop)))) {
                return 9;
            } else if (")".equals(map_i2s.get(reader.get(readerTop)))) {
                return 9;
            } else if ("}".equals(map_i2s.get(reader.get(readerTop)))) {
                return 9;
            } else if ("#".equals(map_i2s.get(reader.get(readerTop)))) {
                return 9;
            } else if (",".equals(map_i2s.get(reader.get(readerTop)))) {
                return 8;
            } else {
                return -1;
            }
        } else if ("Q".equals(stack.get(stackTop))) {
            if ("}".equals(map_i2s.get(reader.get(readerTop)))) {
                return 11;
            } else if ("$".equals(map_i2s.get(reader.get(readerTop)))) {
                return 11;
            } else if ("else".equals(map_i2s.get(reader.get(readerTop)))) {
                return 10;
            } else {
                return -1;
            }
        } else if ("X".equals(stack.get(stackTop))) {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 12;
            } else if ("num".equals(map_i2s.get(reader.get(readerTop)))) {
                return 12;
            } else if ("+".equals(map_i2s.get(reader.get(readerTop)))) {
                return 12;
            } else if ("-".equals(map_i2s.get(reader.get(readerTop)))) {
                return 12;
            } else if ("(".equals(map_i2s.get(reader.get(readerTop)))) {
                return 12;
            } else {
                return -1;
            }
        } else if ("E".equals(stack.get(stackTop))) {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 15;
            } else if ("num".equals(map_i2s.get(reader.get(readerTop)))) {
                return 15;
            } else if ("(".equals(map_i2s.get(reader.get(readerTop)))) {
                return 15;
            } else if ("+".equals(map_i2s.get(reader.get(readerTop)))) {
                return 13;
            } else if ("-".equals(map_i2s.get(reader.get(readerTop)))) {
                return 14;
            } else {
                return -1;
            }
        } else if ("E'".equals(stack.get(stackTop))) {
            if ("+".equals(map_i2s.get(reader.get(readerTop)))) {
                return 16;
            } else if ("-".equals(map_i2s.get(reader.get(readerTop)))) {
                return 16;
            } else if (">".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if (">=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if ("<".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if ("<=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if ("==".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if ("!=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if (";".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else if (")".equals(map_i2s.get(reader.get(readerTop)))) {
                return 17;
            } else {
                return -1;
            }
        } else if ("M".equals(stack.get(stackTop))) {
            if ("+".equals(map_i2s.get(reader.get(readerTop)))) {
                return 18;
            } else if ("-".equals(map_i2s.get(reader.get(readerTop)))) {
                return 19;
            } else {
                return -1;
            }
        } else if ("T".equals(stack.get(stackTop))) {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 20;
            } else if ("num".equals(map_i2s.get(reader.get(readerTop)))) {
                return 20;
            } else if ("(".equals(map_i2s.get(reader.get(readerTop)))) {
                return 20;
            }
        } else if ("T'".equals(stack.get(stackTop))) {
            if ("+".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("-".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("*".equals(map_i2s.get(reader.get(readerTop)))) {
                return 21;
            } else if ("/".equals(map_i2s.get(reader.get(readerTop)))) {
                return 21;
            } else if (">".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if (">=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("<".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("<=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("==".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if ("!=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if (";".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else if (")".equals(map_i2s.get(reader.get(readerTop)))) {
                return 22;
            } else {
                return -1;
            }
        } else if ("N".equals(stack.get(stackTop))) {
            if ("*".equals(map_i2s.get(reader.get(readerTop)))) {
                return 23;
            } else if ("/".equals(map_i2s.get(reader.get(readerTop)))) {
                return 24;
            } else {
                return -1;
            }
        } else if ("F".equals(stack.get(stackTop))) {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 25;
            } else if ("num".equals(map_i2s.get(reader.get(readerTop)))) {
                return 26;
            } else if ("(".equals(map_i2s.get(reader.get(readerTop)))) {
                return 27;
            } else {
                return -1;
            }
        } else if ("R".equals(stack.get(stackTop))) {
            if (">".equals(map_i2s.get(reader.get(readerTop)))) {
                return 28;
            } else if (">=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 29;
            } else if ("<".equals(map_i2s.get(reader.get(readerTop)))) {
                return 30;
            } else if ("<=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 31;
            } else if ("==".equals(map_i2s.get(reader.get(readerTop)))) {
                return 32;
            } else if ("!=".equals(map_i2s.get(reader.get(readerTop)))) {
                return 33;
            } else {
                return -1;
            }
        } else if ("S'".equals(stack.get(stackTop))) {
            if ("char".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("short".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("int".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("long".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("float".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("double".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("if".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("while".equals(map_i2s.get(reader.get(readerTop)))) {
                return 34;
            } else if ("#".equals(map_i2s.get(reader.get(readerTop)))) {
                return 35;
            }
            else if ("}".equals(map_i2s.get(reader.get(readerTop)))) {
                return 35;
            }else {
                return -1;
            }
        } else if ("A".equals(stack.get(stackTop))) {
            if ("char".equals(map_i2s.get(reader.get(readerTop)))) {
                return 36;
            } else if ("short".equals(map_i2s.get(reader.get(readerTop)))) {
                return 37;
            } else if ("int".equals(map_i2s.get(reader.get(readerTop)))) {
                return 38;
            } else if ("long".equals(map_i2s.get(reader.get(readerTop)))) {
                return 39;
            } else if ("float".equals(map_i2s.get(reader.get(readerTop)))) {
                return 40;
            } else if ("double".equals(map_i2s.get(reader.get(readerTop)))) {
                return 41;
            } else if("id".equals(map_i2s.get(reader.get(readerTop)))){
                return 43;
            }else {
                return -1;
            }
        }else if("A'".equals(stack.get(stackTop)))
        {
            if ("id".equals(map_i2s.get(reader.get(readerTop)))) {
                return 43;
            } else if ("main".equals(map_i2s.get(reader.get(readerTop)))) {
                return 42;
            } else{
                return -1;
            }
        } else {
            System.out.println("语法错误");
        }
        return -1;
    }

    /**
     * 比较栈里面的符号
     * @param stackTop
     * @param readerTop
     * @return
     */
    private static boolean match(int stackTop, int readerTop) {
        try {
            int stackTopVal = Integer.valueOf(stack.get(stackTop)); // 未抛出异常说明是终结符
            if (stackTopVal == reader.get(0)) {
                stack.remove(stackTop);
                reader.remove(readerTop);
                return true;
            } else {
                return false;
            }
        } catch (NumberFormatException e) {
            // 抛出异常说明是非终结符
            return false;
        }
    }

    /**
     * 初始化产生式
     */
    private static void initProductions() {
        productions[0] = new Production("S",
                new String[]{"A", "A'"},
                "S --> AA'");
        productions[1] = new Production("S",
                new String[]{String.valueOf(map_s2i.get("id")), "B"},
                "S --> id B");
        productions[2] = new Production("S",
                new String[]{String.valueOf(map_s2i.get("if")), String.valueOf(map_s2i.get("(")), "X", String.valueOf(map_s2i.get(")")), String.valueOf(map_s2i.get("{")), "S", String.valueOf(map_s2i.get("}")), "Q"},
                "S --> if(X){S}Q");
        productions[3] = new Production("S",
                new String[]{String.valueOf(map_s2i.get("while")), String.valueOf(map_s2i.get("(")), "X", String.valueOf(map_s2i.get(")")), String.valueOf(map_s2i.get("{")), "S", String.valueOf(map_s2i.get("}"))},
                "S --> while(X){S}");
        productions[4] = new Production("S",
                new String[]{"ε"},
                "S --> ε");
        productions[5] = new Production("B",
                new String[]{String.valueOf(map_s2i.get("(")), "L", String.valueOf(map_s2i.get(")")), String.valueOf(map_s2i.get(";"))},
                "B --> (L);");
        productions[6] = new Production("B",
                new String[]{String.valueOf(map_s2i.get("=")), "E", String.valueOf(map_s2i.get(";"))},
                "B --> =E;");
        productions[7] = new Production("L",
                new String[]{String.valueOf(map_s2i.get("id")), "L'"},
                "L --> id L'");
        productions[8] = new Production("L'",
                new String[]{String.valueOf(map_s2i.get(",")), String.valueOf(map_s2i.get("id")), "L'"},
                "L' --> ,id L'");
        productions[9] = new Production("L'",
                new String[]{"ε"},
                "L' --> ε");
        productions[10] = new Production("Q",
                new String[]{String.valueOf(map_s2i.get("else")), String.valueOf(map_s2i.get("{")), "S", String.valueOf(map_s2i.get("}"))},
                "Q --> else{S}");
        productions[11] = new Production("Q",
                new String[]{"ε"},
                "Q --> ε");
        productions[12] = new Production("X",
                new String[]{"E", "R", "E"},
                "X --> ERE");
        productions[13] = new Production("E",
                new String[]{String.valueOf(map_s2i.get("+")), "T", "E'"},
                "E --> +TE'");
        productions[14] = new Production("E",
                new String[]{String.valueOf(map_s2i.get("-")), "T", "E'"},
                "E --> -TE'");
        productions[15] = new Production("E",
                new String[]{"T", "E'"},
                "E --> TE'");
        productions[16] = new Production("E'",
                new String[]{"M", "E'"},
                "E' --> ME'");
        productions[17] = new Production("E'",
                new String[]{"ε"},
                "E' --> ε");
        productions[18] = new Production("M",
                new String[]{String.valueOf(map_s2i.get("+")), "T"},
                "M --> +T");
        productions[19] = new Production("M",
                new String[]{String.valueOf(map_s2i.get("-")), "T"},
                "M --> -T");
        productions[20] = new Production("T",
                new String[]{"F", "T'"},
                "T --> FT'");
        productions[21] = new Production("T'",
                new String[]{"N", "T'"},
                "T' --> NT'");
        productions[22] = new Production("T'",
                new String[]{"ε"},
                "T' --> ε");
        productions[23] = new Production("N",
                new String[]{String.valueOf(map_s2i.get("*")), "F"},
                "N --> *F");
        productions[24] = new Production("N",
                new String[]{String.valueOf(map_s2i.get("/")), "F"},
                "N --> /F");
        productions[25] = new Production("F",
                new String[]{String.valueOf(map_s2i.get("id"))},
                "F --> id");
        productions[26] = new Production("F",
                new String[]{String.valueOf(map_s2i.get("num"))},
                "F --> num");
        productions[27] = new Production("F",
                new String[]{String.valueOf(map_s2i.get("(")), "E", String.valueOf(map_s2i.get(")"))},
                "F --> (E)");
        productions[28] = new Production("R",
                new String[]{String.valueOf(map_s2i.get(">"))},
                "R --> >");
        productions[29] = new Production("R",
                new String[]{String.valueOf(map_s2i.get(">="))},
                "R --> >=");
        productions[30] = new Production("R",
                new String[]{String.valueOf(map_s2i.get("<"))},
                "R --> <");
        productions[31] = new Production("R",
                new String[]{String.valueOf(map_s2i.get("<="))},
                "R --> <=");
        productions[32] = new Production("R",
                new String[]{String.valueOf(map_s2i.get("=="))},
                "R --> ==");
        productions[33] = new Production("R",
                new String[]{String.valueOf(map_s2i.get("!="))},
                "R --> !=");
        productions[34] = new Production("S'",
                new String[]{"S", "S'"},
                "S' --> SS'");
        productions[35] = new Production("S'",
                new String[]{"ε"},
                "S' --> ε");
        productions[36] = new Production("A",
                new String[]{String.valueOf(map_s2i.get("char"))},
                "A --> char");
        productions[37] = new Production("A",
                new String[]{String.valueOf(map_s2i.get("short"))},
                "A --> short");
        productions[38] = new Production("A",
                new String[]{String.valueOf(map_s2i.get("int"))},
                "A --> int");
        productions[39] = new Production("A",
                new String[]{String.valueOf(map_s2i.get("long"))},
                "A --> long");
        productions[40] = new Production("A'",
                new String[]{String.valueOf(map_s2i.get("float"))},
                "A --> float");
        productions[41] = new Production("A",
                new String[]{String.valueOf(map_s2i.get("double"))},
                "A --> double");
        productions[42] = new Production("A'",
                new String[]{String.valueOf(map_s2i.get("main")),String.valueOf(map_s2i.get("(")),String.valueOf(map_s2i.get(")")), String.valueOf(map_s2i.get("{")), "S'", String.valueOf(map_s2i.get("}"))},
                "A' --> main(){S'}");
        productions[43] = new Production("A'",
                new String[]{"L", String.valueOf(map_s2i.get(";"))},
                "A' --> L;");
        productions[44] = new Production("S",
                new String[]{"A","A'"},
                "S --> AA'");
    }

    /**
     * 存储符号表，散列表
     */
    private static void initMap(){
        //HashMap 散列表
        map_s2i = new HashMap<>();
        map_s2i.put("id",1);//标识符
        map_s2i.put("num",2);//常数
        map_s2i.put(",",3);
        map_s2i.put(";",4);
        map_s2i.put(":",5);
        map_s2i.put("(",6);
        map_s2i.put(")",7);
        map_s2i.put("{",8);
        map_s2i.put("}",9);
        map_s2i.put("class",10);
        map_s2i.put("new",11);
        map_s2i.put("static",12);
        map_s2i.put("break",13);
        map_s2i.put("continue",14);
        map_s2i.put("return",15);
        map_s2i.put("do",16);
        map_s2i.put("while",17);
        map_s2i.put("if",18);
        map_s2i.put("else",19);
        map_s2i.put("for",20);
        map_s2i.put("switch",21);
        map_s2i.put("case",22);
        map_s2i.put("default",23);
        map_s2i.put("char",24);
        map_s2i.put("double",25);
        map_s2i.put("float",26);
        map_s2i.put("int",27);
        map_s2i.put("long",28);
        map_s2i.put("short",29);
        map_s2i.put("string",30);
        map_s2i.put("null",31);
        map_s2i.put("true",32);
        map_s2i.put("false",33);
        map_s2i.put("void",34);
        map_s2i.put("this",35);
        map_s2i.put("goto",36);
        map_s2i.put("endl",37);
        map_s2i.put("cout",38);
        map_s2i.put("cin",39);
        map_s2i.put("main",40);
        map_s2i.put("+",41);
        map_s2i.put("-",42);
        map_s2i.put("*",43);
        map_s2i.put("-=",44);
        map_s2i.put("*=",45);
        map_s2i.put("/=",46);
        map_s2i.put("<<",47);
        map_s2i.put(">>",48);
        map_s2i.put("==",49);
        map_s2i.put("!=",50);
        map_s2i.put(">",51);
        map_s2i.put("<",52);
        map_s2i.put("=",53);
        map_s2i.put(">=",54);
        map_s2i.put("<=",55);
        map_s2i.put("&&",56);
        map_s2i.put("||",56);
        map_s2i.put("!",58);
        map_s2i.put(".",59);
        map_s2i.put("strings",60);//字符串
        map_s2i.put("#",61);

        map_i2s = new HashMap<>();
        map_i2s.put(1,"id");//标识符
        map_i2s.put(2,"num");//常数
        map_i2s.put(3,",");
        map_i2s.put(4,";");
        map_i2s.put(5,":");
        map_i2s.put(6,"(");
        map_i2s.put(7,")");
        map_i2s.put(8,"{");
        map_i2s.put(9,"}");
        map_i2s.put(10,"class");
        map_i2s.put(11,"new");
        map_i2s.put(12,"static");
        map_i2s.put(13,"break");
        map_i2s.put(14,"continue");
        map_i2s.put(15,"return");
        map_i2s.put(16,"do");
        map_i2s.put(17,"while");
        map_i2s.put(18,"if");
        map_i2s.put(19,"else");
        map_i2s.put(20,"for");
        map_i2s.put(21,"switch");
        map_i2s.put(22,"case");
        map_i2s.put(23,"default");
        map_i2s.put(24,"char");
        map_i2s.put(25,"double");
        map_i2s.put(26,"float");
        map_i2s.put(27,"int");
        map_i2s.put(28,"long");
        map_i2s.put(29,"short");
        map_i2s.put(30,"string");
        map_i2s.put(31,"null");
        map_i2s.put(32,"true");
        map_i2s.put(33,"false");
        map_i2s.put(34,"void");
        map_i2s.put(35,"this");
        map_i2s.put(36,"goto");
        map_i2s.put(37,"endl");
        map_i2s.put(38,"cout");
        map_i2s.put(39,"cin");
        map_i2s.put(40,"main");
        map_i2s.put(41,"+");
        map_i2s.put(42,"-");
        map_i2s.put(43,"*");
        map_i2s.put(44,"-=");
        map_i2s.put(45,"*=");
        map_i2s.put(46,"/=");
        map_i2s.put(47,"<<");
        map_i2s.put(48,">>");
        map_i2s.put(49,"==");
        map_i2s.put(50,"!=");
        map_i2s.put(51,">");
        map_i2s.put(52,"<");
        map_i2s.put(53,"=");
        map_i2s.put(54,">=");
        map_i2s.put(55,"<=");
        map_i2s.put(56,"&&");
        map_i2s.put(57,"||");
        map_i2s.put(58,"!");
        map_i2s.put(59,".");
        map_i2s.put(60,"strings");//字符串
        map_i2s.put(61,"#");
    }

    /**
     * 定义产生式
     */
    private static class Production {
        String l_str;//
        String[] r_str;
        String prod;
        public Production(String l_str, String[] r_str, String prod) {
            this.l_str = l_str;
            this.r_str = r_str;
            this.prod = prod;
        }
    }

}
Joise.
关注
词法分析器和语法分析器
06-13
编译原理词法分析器和语法分析器，简单易懂，超强大，尤其适合自己动手模仿写编译器的同学。
java 实现词法分析器以及语法分析器
06-29
由于这学期学了编译原理这门课，实验要求写词法分析器以及语法分析器，这才写的，不同网络其他的代码，我采用的是java实现的，也算费了好多脑细胞，希望能大伙看看咋样，不喜勿喷哦，各自学习就是了！
词法与语法分析器介绍
weixin_40398522的博客
05-27 831
词法和语法可以使用正则表达式和BNF范式表达，而最终描述文法含义的事状态转换图。
编译器之词法分析
听老罗娓娓道来
09-27 1112
ifelse标识符：以字母开头，后面可以跟任意数量的字母或数字数字：一个或多个数字字符if | else // 关键字[a-zA-Z][a-zA-Z0-9]* // 标识符[0-9]+ // 数字[+\-*/] // 运算符然后，我们可以使用Lex或Flex等工具来生成相应的词法分析器代码。总之，词法分析的底层原理涉及到形式语言和自动机理论，通过正则表达式和有限状态自动机来实现对源代码字符序列的模式匹配和Token识别。# Token类型定义# Token类。
编译原理-词法分析器，语法分析器-课程设计
weixin_34327761的博客
04-10 708
2019独角兽企业重金招聘Python工程师标准>>> ...
词法分析、语法分析
lijinlijin_的博客
05-05 468
词法分析的任务是：从左往右逐个字符地扫描源程序，产生一个个的单词符号。也就是说，它会对输入的字符流进行处理，再输出单词流。执行词法分析的程序即，或者说扫描器。词法分析的成果就是由一系列单词符号构成的单词流。单词种别通常用整数编码表示若一个种别只有一个单词符号，则种别编码就代表该单词符号。假定基本字、运算符和符都是一符一种。若一个种别有多个单词符号，则对于每个单词符号，给出种别编码和自身的值。
编译原理课程设计-基于C++实现编译原理词法分析器&语法分析器LR(1)+项目源码+源程序+文档说明+课程设计报告
最新发布
11-06
编译原理词法分析器&语法分析器LR(1) 计算机本科编译原理课程设计，包含词法分析器，LR(1)语法分析器 功能完整，有注释。 - 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设，代码都测试ok，...
编译原理词法分析器&语法分析器LR(1)实现 C++.zip
04-17
对于这个编译原理的项目，它可能详细解释了如何运行和测试词法分析器和语法分析器的代码。 总的来说，这个课程设计涵盖了编译器的核心部分，即词法分析和语法分析，并使用了C++编程语言以及LR(1)解析技术。通过实践...
编译原理词法分析器及语法分析器实验报告，JAVA实现
06-26
词法分析是编译原理中的基础步骤，它的主要任务是对源代码进行扫描，将源程序中的字符流分解...通过这个实验，学生能够掌握如何构建一个简单的词法分析器，这对于理解编译器的工作原理和构建更复杂的编译工具至关重要。
编译原理词法分析器和语法分析器的实现（C++）.zip
04-17
编译原理词法分析器和语法分析器的实现（C++） 编译原理中的词法分析器和语法分析器是编译器的重要组成部分，它们分别负责将源代码转换为词法单元和抽象语法树。以下是一个简化的项目介绍，描述了如何使用C++实现这...
编译原理词法分析器和语法分析器实验报告附源码.zip
12-02
这份"编译原理词法分析器和语法分析器实验报告附源码.zip"的压缩包文件，很显然包含了对这两个概念的实践应用及源代码，非常适合学习和理解编译器的工作原理。 词法分析器（Lexer或Scanner）是编译器的第一步，它的...
编译原理词法分析器、语法分析器python实现
05-28
python实现的词法分析器和语法分析器，哈工大威海编译原理实现，词法分析器能够识别字符串，能够判断所输入的字符串是否符合文法，语法分析器采用自底向上的LR0实现。
词法分析器与语法分析器
06-03
JAVA 实现的词法分析器与语法分析器。 输出有词法二元表
编译原理课程设计词法语法分析器
01-09
编译原理课程设计词法语法分析器 编译原理课程设计词法语法分析器
编译原理词法语法分析器
10-21
编译原理的课程设计，用C++做的，比较简单的此法语法分析器，有课程设计报告
【编译原理】图灵机、词法分析和语法分析
qq_46130027的博客
02-12 481
从词汇分析阶段的叶子序列开始，在我们朝着＜program＞的方向前进时，尝试构建树的一部分。当解析器需要做出决定时，它会查看输入流中接下来的几个标记，以帮助做出正确的决定。从顶部开始搜索，从< program >开始，尝试向下搜索填充在树中的树叶。形式上，对于指定的字符串α，识别它是否是指定语法G（Z）的句子。LL（k）解析器生成最左边的派生，并且是自顶向下的解析器。LR（k）解析器生成最右边的派生，是一种自下而上的方法。k是允许的前瞻符号（令牌）的数量；两组主要的解析策略，称为LL（k）和LR（k）
LLVM学习日志4——Kaleidoscope：词法分析器和语法分析器
tristan_tian的博客
08-13 5155
要实现一门语言，第一要务就是要能够处理文本文件，搞明白其中究竟写了些什么。传统上，我们会先利用“词法分析器”（也称为“扫描器”）将输入切成“语元（token）”，然后再做处理。词法分析器返回的每个语元都带有一个语元编号，此外可能还会附带一些元数据（比如某个数值）。 看了词法分析器的教程，第一章大概就是讲了如何用语元（token）来表示每个词，使用函数不断读取每个词，并且判断和分类。 词法分析器...
杭州电子科技大学编译原理词法分析器设计
资源摘要信息:"新建文件夹_编译原理词法分析器_" 知识点一：编译原理概述 编译原理是计算机科学领域中关于程序设计语言处理的一门重要学科，主要研究如何将高级语言编写的源程序转换成机器可以执行的代码。编译过程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值