sp_parser.java

JAVA编程实现用于处理表达式的简单编译器

import  java.util.*;

/**
 * 语法分析器 
 *
 * @author  林玉东.烟台
 * @version 1.0 11/01 2003 
 */ 
public class SP_Parser  implements SP_Const
{
	//
	private SP_Scanner  scanner;
	private SP_Function functioner;
	private SP_SimpleParseUI impl;     //与实际应用接口引用

	//
	public SP_Parser()
	{
		this.impl=new SP_SimpleParseUI(){
			public boolean  isVariable(String ident) {return false;}
			public String   getVariableValue(String vname){return null;}
			public int  getVariableType(String vname){return SP_Const.WT_StringConst;}
			public String   getVariableValue(String vname,Object args){return null;}
			public boolean  isUserFunction(String fname) {return false;}
			public void proUserFunction(SP_Parser  parser,String fname,SP_RunUnit src){}
		};
		scanner=new SP_Scanner(impl);
		functioner=new SP_Function(this,impl);
	}
	public SP_Parser(SP_SimpleParseUI impl)
	{
		this.impl=impl;
		scanner=new SP_Scanner(impl);
		functioner=new SP_Function(this,impl);
	}
	public SP_Scanner getScanner()
	{
		return scanner;
	}
	public String calExpress(String express)
	{
		scanner.setScanExpress(express);
		SP_RunUnit result=new SP_RunUnit();
		try{
			proLogicExpress1(result);
			return result.getValue();
		}
		catch(Exception e){
			System.out.println("表达式("+express+")存在错误:"+e.getMessage());
			return express;
		}
	}

	//处理逻辑表达式1（ || ）
	public void proLogicExpress1(SP_RunUnit src)
		throws Exception
	{
		proLogicExpress2(src);
		scanner.readOneWord();
		while(scanner.curWordType==WT_R_OR && scanner.hasMoreWord())
		{
			SP_RunUnit targ=new SP_RunUnit();
			proLogicExpress2(targ);
			src.or(targ);
			scanner.readOneWord();
		}
		scanner.backSpace(); 
	}
	//处理逻辑表达式2（ && ）
	public void proLogicExpress2(SP_RunUnit src)
		throws Exception
	{
		proRelationExpression(src);
		scanner.readOneWord();
		while(scanner.curWordType==WT_R_AND && scanner.hasMoreWord())
		{
			SP_RunUnit targ=new SP_RunUnit();
			proRelationExpression(targ);
			src.and(targ);
			scanner.readOneWord();
		}
		scanner.backSpace(); 
	}
	//处理关系表达式
	public void proRelationExpression(SP_RunUnit src)
		throws Exception
	{
		proMathExpression1(src);
		scanner.readOneWord();
		int type=scanner.curWordType;
		while(WT_ReservedWord.isRelationType(type) && scanner.hasMoreWord())
		{
			SP_RunUnit targ=new SP_RunUnit();
			proMathExpression1(targ);
			//
			if(type==WT_EQL)
				src.eql(targ);
			else if(type==WT_LSS)
				src.lss(targ);
			else if(type==WT_GTR)
				src.grt(targ);
			else if(type==WT_LEQ)
				src.leq(targ);
			else if(type==WT_GEQ)
				src.geq(targ);
			else if(type==WT_NEQ)
				src.neq(targ);
			scanner.readOneWord();
			type=scanner.curWordType;
		}
		scanner.backSpace(); 
	}

	//处理算术表达式1: ( + - )
	public void proMathExpression1(SP_RunUnit src)
			throws Exception
	{
		proMathExpression2(src);      //结果存储在src单元中
		scanner.readOneWord();
		int type=scanner.curWordType;
		while((type==WT_PLUS || type==WT_MINUS) && scanner.hasMoreWord()){
			SP_RunUnit targ=new SP_RunUnit();
			proMathExpression2(targ); //结果存储在新单元中
			if(type==WT_PLUS)
				src.plus(targ);       //+-的结果存储在src单元中
			else
				src.minus(targ);
			scanner.readOneWord();
			type=scanner.curWordType;
		}
		scanner.backSpace();   //需要仔细
	}
	//处理算术表达式2: ( * / )
	private void proMathExpression2(SP_RunUnit src)
			throws Exception
	{
		proRawExpression(src);      //结果存储在src单元中
		scanner.readOneWord();
		int type=scanner.curWordType;
		while((type==WT_TIMES || type==WT_DIVIDE || type==WT_MOD ) && scanner.hasMoreWord()){
			SP_RunUnit targ=new SP_RunUnit();
			proRawExpression(targ); //结果存储在新单元中
			if(type==WT_TIMES)
				src.times(targ);    //+-的结果存储在src单元中
			else if(type==WT_DIVIDE)
				src.divide(targ);
			else
				src.mod(targ);
			scanner.readOneWord();
			type=scanner.curWordType;
		}
		scanner.backSpace();   //需要仔细
	}
	//处理算术表达式3: 常数/变量/函数/复合
	private void proRawExpression(SP_RunUnit src)
			throws Exception
	{
		scanner.readOneWord();
		int type=scanner.curWordType;
		String val=scanner.curWordValue;
		//符号
		if(type==WT_MINUS || type==WT_PLUS){  //-5... 
			proRawExpression(src); //注意 下次进入只应是常数
			if(type==WT_MINUS)
				src.value1=-src.value1;
		}
		//常数
		else if(type==WT_IntegerConst || type==WT_FloatConst || type==WT_StringConst ){
			src.set(val,type);
		}
		//变量
		else if(type==WT_Variable){
			src.set(impl.getVariableValue(val),impl.getVariableType(val));
		}
		//内部函数
		else if(type==WT_SysFunction){
			functioner.proFunction(val,src);
		}
		//外部函数
		else if(type==WT_UserFunction){
			impl.proUserFunction(this,val,src);
		}
		//
		else if(type==WT_LPAREN){
			scanner.readOneWord();
			//造型
			if(WT_ReservedWord.isReservedWordType(scanner.curWordType)){
				int rt=scanner.curWordType;
				scanner.readOneWord();
				if(scanner.curWordType!=WT_RPAREN)
					throw new Exception("缺少) !");
				proRawExpression(src);
				src.type=WT_ReservedWord.getDataType(rt);
			}
			//复合表达式->( 
			else{  
				scanner.backSpace();
				proLogicExpress1(src);   //从头来
				scanner.readOneWord();
				if(scanner.curWordType!=WT_RPAREN)
					throw new Exception("缺少) !");
			}
		}
		//错误
		else{
			throw new Exception("不识别的字符->"+scanner.curWordType+":"+scanner.curWordValue);
		}
	}
}