celser.java

来自「桂林电子科技大学编译原理完整JAVA源代码(词法、语法、语义) 此为完整版本」· Java 代码 · 共 369 行

package news;

import java.sql.ResultSet;
import java.util.Vector;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
/*/////////////////////////////////////////////////////////
 *P_p()程序 F_p()分程序 S_m()变量说明 Y_g()语句 L_x()类型
 *F_y()赋值语句  T_y()条件判断语句  G_b()关系表达式
 *S_b()算术表达式  X_x()项  Y_s()因式  C_l()常数  N_m()数字
 *G_f()关系符  B_l()变量  Z_m()字母
 *//////////////////////////////////////////////////////////
public class Celser {
    private int n=0,token=0,track=0;//track出错标志,token单词坐标
    private Vector vec=new Vector();//词法分析的单词
    private Vector line=new Vector();//表示行
    private Vector var=new Vector();//存变量
    private String str=new String();
    private String varr=new String();
    public String err=new String();
    private boolean flag=false;
    public Celser() {
        token=0;
        var.clear();
        line.clear();
        vec.clear();
        err="";
        ResultSet rs;
        Sql sq=new Sql();
        String sql;
        String name;
        boolean flag=false; //开关
        sql="select * from 词法分析 where 内部码 <> '88' and 名称 <> 'null'";
        try{
            rs=sq.getResult(sql);
            rs.beforeFirst();
            while(rs.next()){
                name=rs.getString("名称");
                vec.add(name);
                line.add(rs.getString("行"));
                varr=rs.getString("内部码");
                if(name.equals("int")||name.equals("real")||name.equals("char")) {
                    flag=true;
                }
                if(flag) {
                    if(varr.equals("3")) {
                        var.add(name);
                        flag=false;
                    }
                }
            }
            rs.refreshRow();
            rs.close();
        } catch (Exception ex) {
        }
    }
    //递归下降法过程(所有返回1的为真，当返回100表示成功，否则为假)
    public int P_p(){  //<程序> → main(){分程序}
        token=0;
        err="Error:"+this.line.elementAt(token).toString()+"行缺少关键字: main";
        if(nextToken(token).equals("main")) {
            {
                match();
                track=2;
                err="Error:"+line.elementAt(token).toString()+"行main后面缺少分隔符: (";
                if(nextToken(token).equals("(")) {
                    match();
                    track=2;
                    err="Error:"+line.elementAt(token).toString()+"行(后面缺少分隔符: )";
                    if(nextToken(token).equals(")")) {
                        match();
                        track=2;
                        err="Error:"+line.elementAt(token).toString()+"行)后面缺少分隔符: {";
                        if(nextToken(token).equals("{")){
                            match();
                            track=2;
                            if(F_p()==1) {
                                track=90;
                                err="Error:"+line.elementAt(token).toString()+"行"+vec.elementAt(token).toString()+"位置出错！";
                                if(nextToken(token).equals("}")) {
                                    track=100;
                                    err="语法分析成功!";
                                }
                            }
                        }
                    }
                }
            }
        }
        return track;
    }
    private int F_p(){  //<分程序> → <变量说明> <语句>
        track=9;//变量说明||语句出错标志
        if(S_m()==1) {
            track=36;
            if(Y_g()==1) {
                track=1;
            }
        }
        return  track;
    }
    private int S_m(){ //<变量说明> → <类型> <变量>；| <类型> <变量>；<变量说明>
        track=10;
        if(L_x()==1) {
            track=11;
            if(B_l()==1){
                track=2;
                err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token-1)+"位置有错";
                if(nextToken(token).equals(";")) {
                    match();
                    track=38;
                    if(S_m()==1) {
                        track=1;
                    } else {
                        track=1;
                    }
                }
            }
        }
        return track;
    }
    private int L_x() {  //<类型> → int | real | char
        track=10;
        String s=nextToken(token);
        if(s.equals("int")||s.equals("real")||s.equals("char")) {
            match();
            track=1;
        }else
        {
            err="Error:"+line.elementAt(token).toString()+"行"+s+"不是类型: int|char|real";
        }
        return track;
    }
    private int Y_g(){ //<语句> → <赋值语句> | <条件判断语句>
        track=13;
        if(F_y()==1) {
            track=1;
        } else if(T_y()==1) {
            track=1;
        }
        
        return track;
    }
    private int F_y(){ //<赋值语句> → <变量> ＝ <算术表达式>；| <变量> ＝ <算术表达式>；<赋值语句>
        track=14;
        if(nextToken(token).equals("else")||nextToken(token).equals("}")) {
            return track=1;
        }
        if(B_l()==1) {
            track=2;
            err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token)+"位置有错";
            if(nextToken(token).equals("=")) {
                match();
                track=16;
                if(S_b()==1) {
                    track=2;
                    err="Error:"+line.elementAt(token).toString()+"行位置有错";
                    if(nextToken(token).equals(";")) {
                        match();
                        if(F_yy()==1) {
                            track=1;
                        }
                    }
                }
            }
        }
        return track;
    }
    private int F_yy(){
        track=1;
        if(F_y()==1){
            track=1;
        }
        return track;
    }
    private int T_y(){  //<条件判断语句> → if  <关系表达式> <语句>T  T→ 空|else  <语句>
        track=4;
        err="Error:"+line.elementAt(token).toString()+"行位置有错";
        if(nextToken(token).equals("if")) {
            match();
            track=18;
            if(G_b()==1) {
                track=19;
                if(Y_g()==1) {
                    track=1;   //表示空
                    if(T_yy()==1){
                        track=1;
                    }
                }
            }
        }
        return track;
    }
    private int T_yy(){
        track=1;
        err="Error:"+line.elementAt(token).toString()+"行位置有错";
        if(nextToken(token).equals("else")) {
            match();
            track=40;
            if(Y_g()==1) {
                track=1;
            }
        }
        return track;
    }
    private int G_b(){ //<关系表达式> → <算术表达式><关系符><算术表达式>
        track=20;
        if(S_b()==1) {
            track=21;
            if(G_f()==1) {
                track=22;
                if(S_b()==1) {
                    track=1;
                }
            }
        }
        return track;
    }
    private int S_b(){ //<算术表达式> → <项>S    S→ +<算术表达式>|－<算术表达式>
        track=23;
        if(X_x()==1) {
            track=3;
            err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token)+"位置有错";
            if(nextToken(token).equals("+")) {
                match();
                track=55;
                if(S_b()==1)
                    track=1;
            }else{
                track=3;
                err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token)+"位置有错";
                if(nextToken(token).equals("-")) {
                    match();
                    track=26;
                    if(S_b()==1)
                        track=1;
                }else {
                    track=1;   //只有一项时
                }
            }
        }
        return track;
    }
    private int X_x(){  //<项> → <因式> Y   Y → *<项>| /<项>
        track=27;
        if(Y_s()==1) {
            track=3;
            err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token)+"位置有错";
            if(nextToken(token).equals("*")) {
                match();
                track=38;
                if(X_x()==1)
                    track=1;
            } else {
                track=3;
                err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token-1)+"后面缺少运算符: /";
                if(nextToken(token).equals("/")) {
                    match();
                    track=29;
                    if(X_x()==1)
                        track=1;
                } else {
                    track=1;
                }
            }
        }
        return track;
    }
    private int Y_s(){   //<因式> → <变量> | <常数>|（<算术表达式>）
        track=30;
        if(B_l()==1) {
            track=1;
        }else {
            if(C_l()==1) {
                track=1;
            }else {
                track=2;
                err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token-1)+"位置有错";
                if(nextToken(token).equals("(")) {
                    match();
                    track=31;
                    if(S_b()==1) {
                        track=2;
                        err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token-1)+"位置有错";
                        if(nextToken(token).equals(")")) {
                            match();
                            track=1;
                        }
                    }
                }
            }
        }
        return track;
    }
    private int C_l(){ //常量包括浮点和整数
        track=13;
        if(isNumeric(nextToken(token))) {
            track=1;
            match();
        }
        return track;
    }
    private int G_f(){  //<关系符> → <|<=|=|>|>=|!=|&&
        track=5;
        String s=nextToken(token);
       
        if(s.equals("<")||s.equals("<=")||s.equals("==")||s.equals(">=")||s.equals("!=")||s.equals(">")||s.equals("&&")) {
            track=1;
            match();
        }else
        { 
            err="Error:"+line.elementAt(token).toString()+"行"+this.vec.elementAt(token)+"缺少关系符: <|<=|==|>|>=|&&|!=";
        }
          
        return track;
    }
    private int B_l(){ //变量
        track=12;
        err="";
        String str=nextToken(token);
        if(str.equals("if"))
            return track;
        if(isB_l(str)) {
            for(int n=0;n<var.size();n++) {
                if(str.equals(var.elementAt(n))) {
                    track=1;
                    match();
                }else
                {
                    err="Error:"+line.elementAt(token).toString()+"变量"+str+"没有被声明";
                }
            }
        }else{
             err="Error:"+line.elementAt(token).toString()+"标识符"+str+"有错！";
        }
        
        return track;
    }
    
    private String nextToken(int token){
        str=vec.elementAt(token).toString();
        return str;
    }
    private void match(){
        if(token<vec.size()-1) {
            this.token=token+1;
        }
    }
    public boolean isB_l(String str) //判断变量(字符是否都为数字组成还是点数)
    {
        Pattern pattern = Pattern.compile("[a-z|A-Z]+[0-9]*");
        Matcher isNum = pattern.matcher(str);
        if( !isNum.matches()) {
            return false;
        }
        return true;
    }
    public static boolean isNumeric(String str) //判断常数(字符是否都为数字组成还是点数)
    {
        Pattern pattern = Pattern.compile("[0-9|.]*");
        Matcher isNum = pattern.matcher(str);
        if( !isNum.matches() ) {
            return false;
        }
        return true;
    }
    
}