scantest.java

一些基本的编译文法的描述 基于java的

import java.io.*;
import java.util.Scanner;
/**
 *
 * @author zhaowei
 */
public class ScanTest {
    private boolean lexicalError = false;
    private boolean syntaxError = false;
    private boolean back = false;
    private LexicalResult current;
    private String input = "";
    private int index = 0;
    public void newTest() {
      //  this.readFromFile(new File("test.txt"));
        Scanner scanner = new Scanner(System.in);
       input= scanner.nextLine().toLowerCase()+" ";
        //*
        while(this.scan()!=null) {
            this.backScan();
            SyntaxTreeNode stn = this.analyseStart();
            if(lexicalError) {
                System.out.println("Lexical Analysis Input Error!");
                return ;
            }
            else if(syntaxError) {
                System.out.println("Systax Analysis Input Error!");
                return ;
            }
            else {
                this.optimizeSyntaxTree(stn);
                this.printSyntaxTree(stn);
            }
        }
       
    }
 
    private LexicalResult scan() {
        if(back == true) {
            back = false;
            return current;
        }
        else if(index<input.length()-1) {
            while(input.charAt(index)==' ') {
                if(index==input.length()-1) {
                    current = null;
                    return null;
                }
                index++;
            }
            if(input.charAt(index)<='z'&&input.charAt(index)>='a') {
                int startIndex = index;
                index++;
                while((input.charAt(index)>='a'&&input.charAt(index)<='z')||(input.charAt(index)>='0'&&input.charAt(index)<='9')) {
                    index++;
                }
                if(input.substring(startIndex,index).equals("if")) {
                    current = new LexicalResult("if","-");
                    return new LexicalResult("if","-");
                }
                else if(input.substring(startIndex,index).equals("then")) {
                    current = new LexicalResult("then","-");
                    return new LexicalResult("then","-");
                }
                else if(input.substring(startIndex,index).equals("else")) {
                    current = new LexicalResult("else","-");
                    return new LexicalResult("else","-");
                }
                else if(input.substring(startIndex,index).equals("while")) {
                    current = new LexicalResult("while","-");
                    return new LexicalResult("while","-");
                }
                else if(input.substring(startIndex,index).equals("do")) {
                    current = new LexicalResult("do","-");
                    return new LexicalResult("do","-");
                }
                else if(input.substring(startIndex,index).equals("begin")) {
                    current = new LexicalResult("begin","-");
                    return new LexicalResult("begin","-");
                }
                else if(input.substring(startIndex,index).equals("end")) {
                    current = new LexicalResult("end","-");
                    return new LexicalResult("end","-");
                }
                else {
                    current = new LexicalResult("IDN",input.substring(startIndex,index));
                    return new LexicalResult("IDN",input.substring(startIndex,index));
                }
            }
            else if(input.charAt(index)>='1'&&input.charAt(index)<='9') {
                int startIndex = index;
                index++;
                while(input.charAt(index)>='0'&&input.charAt(index)<='9') {
                    index++;
                }
                current = new LexicalResult("INT10",input.substring(startIndex,index));
                return new LexicalResult("INT10",input.substring(startIndex,index));
            }
            else if(input.charAt(index)=='0') {
                int startIndex = index;
                index++;
                if(input.charAt(index)>='0'&&input.charAt(index)<='7') {
                    index++;
                    while(input.charAt(index)>='0'&&input.charAt(index)<='7') {
                        index++;
                    }
                    current = new LexicalResult("INT8",Integer.valueOf(input.substring(startIndex+1,index),8).toString());
                    return new LexicalResult("INT8",Integer.valueOf(input.substring(startIndex+1,index),8).toString());
                }
                else if(input.charAt(index)=='x') {
                    index++;
                    if((input.charAt(index)>='0'&&input.charAt(index)<='9')||(input.charAt(index)>='a'&&input.charAt(index)<='f')) {
                        index++;
                    }
                    while((input.charAt(index)>='0'&&input.charAt(index)<='9')||(input.charAt(index)>='a'&&input.charAt(index)<='f')) {
                        index++;
                    }
                    if((startIndex+2)==index) {
                        lexicalError();
                    }
                    else {
                        current = new LexicalResult("INT16",Integer.valueOf(input.substring(startIndex+2,index),16).toString());
                        return new LexicalResult("INT16",Integer.valueOf(input.substring(startIndex+2,index),16).toString());
                    }
                }
                else {
                    current = new LexicalResult("INT10",input.substring(startIndex,index));
                    return new LexicalResult("INT10",input.substring(startIndex,index));
                }
            }
            else if(input.charAt(index)=='+') {
                index++;
                current = new LexicalResult("+","-");
                return new LexicalResult("+","-");
            }
            else if(input.charAt(index)=='-') {
                index++;
                current = new LexicalResult("-","-");
                return new LexicalResult("-","-");
            }
            else if(input.charAt(index)=='*') {
                index++;
                current = new LexicalResult("*","-");
                return new LexicalResult("*","-");
            }
            else if(input.charAt(index)=='/') {
                index++;
                current = new LexicalResult("/","-");
                return new LexicalResult("/","-");
            }
            else if(input.charAt(index)=='<') {
                index++;
                current = new LexicalResult("<","-");
                return new LexicalResult("<","-");
            }
            else if(input.charAt(index)=='>') {
                index++;
                current = new LexicalResult(">","-");
                return new LexicalResult(">","-");
            }
            else if(input.charAt(index)=='(') {
                index++;
                current = new LexicalResult("(","-");
                return new LexicalResult("(","-");
            }
            else if(input.charAt(index)==')') {
                index++;
                current = new LexicalResult(")","-");
                return new LexicalResult(")","-");
            }
            else if(input.charAt(index)=='=') {
                index++;
                current = new LexicalResult("=","-");
                return new LexicalResult("=","-");
            }
            else if(input.charAt(index)==';') {
                index++;
                current = new LexicalResult(";","-");
                return new LexicalResult(";","-");
            }
            else {
                lexicalError();
            }
        }
        current = null;
        return null;
    }
    private void backScan() {
        back = true;
    }
    private SyntaxTreeNode analyseStart() {
        SyntaxTreeNode syntaxTree = new SyntaxTreeNode();
        this.analyseS(syntaxTree,true);
        return syntaxTree.getChild();
    }
    private void analyseS(SyntaxTreeNode stn,boolean isChild) {
        if(isChild) {
            stn.setChild(new SyntaxTreeNode("S",null,null));
            stn = stn.getChild();
        }
        else {
            stn.setSibling(new SyntaxTreeNode("S",null,null));
            stn = stn.getSibling();
        }
        LexicalResult lexicalResult = this.scan();
        if(lexicalResult==null) {
            this.syntaxError();
            return ;
        }
        else if(lexicalResult.getType().equals("IDN")) {
            stn.setChild(new SyntaxTreeNode(lexicalResult.getType()+" : "+lexicalResult.getValue(),null,null));
            lexicalResult = this.scan();
            if(lexicalResult==null) {
                this.syntaxError();
                return ;
            }
            stn = stn.getChild();
            if(lexicalResult.getType().equals("=")) {
                stn.setSibling(new SyntaxTreeNode("=",null,null));
                stn = stn.getSibling();
                this.analyseE(stn,false);
            }
            else {
                this.syntaxError();
                return ;
            }
        }
        else if(lexicalResult.getType().equals("if")) {
            stn.setChild(new SyntaxTreeNode(lexicalResult.getType(),null,null));
            stn = stn.getChild();
            this.analyseC(stn,false);
            stn = stn.getSibling();
            lexicalResult = this.scan();
            if(lexicalResult==null) {
                this.syntaxError();
                return ;
            }
            if(lexicalResult.getType().equals("then")) {
                stn.setSibling(new SyntaxTreeNode(lexicalResult.getType(),null,null));
                stn = stn.getSibling();
                this.analyseS(stn,false);
                stn = stn.getSibling();
                lexicalResult = this.scan();
                if(lexicalResult==null) {
                    this.backScan();
                }
                else if(lexicalResult.getType().equals("else")) {
                    stn.setSibling(new SyntaxTreeNode(lexicalResult.getType(),null,null));
                    stn = stn.getSibling();
                    this.analyseS(stn,false);
                }
                else {
                    this.backScan();
                }
            }
            else {
                this.syntaxError();
                return ;
            }
        }
        else if(lexicalResult.getType().equals("while")) {
            stn.setChild(new SyntaxTreeNode(lexicalResult.getType(),null,null));
            stn = stn.getChild();
            this.analyseC(stn,false);
            stn = stn.getSibling();
            lexicalResult = this.scan();
            if(lexicalResult==null) {
                this.syntaxError();
                return ;
            }
            if(lexicalResult.getType().equals("do")) {
                stn.setSibling(new SyntaxTreeNode(lexicalResult.getType(),null,null));
                stn = stn.getSibling();
                this.analyseS(stn,false);
            }
            else {
                this.syntaxError();
                return ;
            }
        }
        else if(lexicalResult.getType().equals("begin")) {
            stn.setChild(new SyntaxTreeNode(lexicalResult.getType(),null,null));
            stn = stn.getChild();