跪求JAVA版的StringResolution.cpp，附C源代码

[wcjunhua]

不熟悉C，但是网上找不到字符串的四则运算解析，只有C++的，希望哪个高人帮我改成JAVA版，非常感谢

// StringResolution.cpp: 
//
//////////////////////////////////////////////////////////////////////
extern"C"
{
#include "../settings.h"
}

#ifdef USE_DBF

#include "StringResolution.h"

#define ISDIGIT(c) ((c)>='0' && (c)<='9')

boolean ISZERO(double d)
{
	if(FCMP_L(d,FASSIGN_INT(0)))
	{
		d = FMUL(d,FASSIGN_INT(-1));
	}
	return FCMP_L(d,DERROR);
}

boolean STR_IsStartBy(char* str, const char* head) 
{
	if(str == NULL)
		return FALSE;
	while(*head !=0) {
		if(*str != *head) return FALSE;
		str++; head++;
	}
	return TRUE;
}

//CStack
CStack::CStack()
{
	datalist = new CBWList(32,FALSE);
}

CStack::~CStack()
{
	delete datalist;
}

boolean CStack::empty()
{
	return datalist->usedcnt == 0;
}

void* CStack::pop()
{
	return (void*)datalist->RemoveTail();
}
void* CStack::top()
{
	return (void*)datalist->GetValue(datalist->usedcnt-1);
}
void CStack::push(void* v)
{
	datalist->AddValue((uint32)v);
}

uint16 CStack::size()
{
	return datalist->usedcnt;
}
//end of CStack

COperator::COperator()
{
}

COperator::~COperator()
{
}

COperand::COperand()
{
	m_startIndex = 0;
	m_IsConst = FALSE;
	MEMSET(m_name,0,sizeof(m_name));
}

COperand::~COperand()
{
}
boolean COperand::operator ==(const COperand &od)
{
	boolean bRet=TRUE;
	bRet=(m_IsConst==od.m_IsConst);
	bRet=(bRet && STRCMP(m_name,od.m_name)==0);
	return bRet;	
}

//
CStringResolution::CStringResolution(char*formula)
:m_oprandNum(0),m_oprandANum(0),m_operatorNum(0)
{
	m_operator=NULL;
	m_oprand=NULL;
	m_oprandA=NULL;
	m_formula = NULL;
	dstname = NULL;
	if(formula)
	{
		m_formula = (char*)STRDUP(formula);
		Initialize();
	}
}

CStringResolution::~CStringResolution()
{
	MYFREEIF(m_operator);
	MYFREEIF(m_oprand);	
	MYFREEIF(m_oprandA);
	MYFREEIF(m_formula);
	MYFREEIF(dstname);
}

char* CStringResolution::GetVariantName(int index)
{
	if(index >=0 && index < m_oprandANum)
	{
		return m_oprandA[index].m_name;
	}
	return NULL;
}

void CStringResolution::SetFormula(char *formula)
{
	if(!formula)
		return;
	if(m_formula)
		FREE(m_formula);
	m_formula = (char*)STRDUP(formula);
	if(m_operator)
	{
		FREE(m_operator);
		m_operator=NULL;
	}
	if(m_oprand)
	{
		FREE(m_oprand);
		m_oprand=0;
	}
	if(m_oprandA)
	{
		FREE(m_oprandA);
		m_oprandA=0;
	}
	m_oprandNum=0,m_oprandANum=0,m_operatorNum=0;
	Initialize();
}

boolean CStringResolution::GetStack(CStack &Operator, CStack &Oprand)
{
	boolean bRet=TRUE;
	EmptyStack(Operator,TRUE);
	EmptyStack(Oprand,FALSE);
	bRet=bRet && GetOperatorStack(Operator,m_formula);
	bRet=bRet && GetOperandStack(Oprand,m_formula);

	return bRet;
}

boolean CStringResolution::EmptyStack(CStack& stack,boolean flag)
{
	while(!stack.empty())
	{
		void *op = stack.pop();
		if(flag)
		{
			COperator *opr = (COperator*)op;
			delete opr;
		}
		else
		{
			COperand *opd = (COperand*)op;
			delete opd;
		}
	}
	return TRUE;
}

boolean CStringResolution::Initialize()
{
	boolean bRet=FALSE;
	CStack Op;
	CStack Od;

	bRet=GetStack(Op,Od);
	if(!bRet)
	{
		EmptyStack(Op,TRUE);
		EmptyStack(Od,FALSE);
		return FALSE;
	}
	
	m_oprandNum = Od.size();
	m_operatorNum = Op.size();
	
	if(m_operatorNum)
		m_operator = (COperator*)MALLOC(sizeof(COperator) * m_operatorNum);
	if(m_oprandNum)
		m_oprand = (COperand*)MALLOC(sizeof(COperand) * m_oprandNum);

	int i;
	for(i=0;i<m_operatorNum;i++)
	{
		COperator *op = (COperator*)Op.top();
		m_operator[m_operatorNum-i-1] = *op;
		Op.pop();
		delete (op);
	}
	for(i=0;i<m_oprandNum;i++)
	{
		COperand*od=(COperand*)Od.top();
		m_oprand[m_oprandNum-i-1]=*od;
		Od.pop();
		delete (od);
	}
	m_oprandA =(COperand*)MALLOC(sizeof(COperand) * m_oprandNum);
	boolean IsIn=FALSE;
	for(i=0;i<m_oprandNum;i++)
	{
		for(int j=0;j<m_oprandANum;j++)
		{
			if(m_oprand[i]==m_oprandA[j])
			{
				IsIn=TRUE;
				break;
			}
		}
		if(!IsIn&&!m_oprand[i].m_IsConst)
		{
			m_oprandA[m_oprandANum]=m_oprand[i];
			m_oprandANum++;
		}
		IsIn=FALSE;
	}
	return TRUE;
}

boolean CStringResolution::GetOperandStack(CStack &Oprand, char* string)
{
	int i=0;
	int j=0;
	int num = STRLEN(string);
	while(i<num)
	{
		if(string[i]=='#' || string[i]=='@' || string[i]==' ' || string[i]=='\t')
			i++;
		else
		{
			COperand * oprand = new COperand;
			if(ISDIGIT(string[i]))
				oprand->m_IsConst=TRUE;
			oprand->m_startIndex=i;
			boolean HasPoint=FALSE;
			while(i < num &&string[i] != '#' && string[i] != '@')
			{
				if(string[i]=='.')
				{
					if(HasPoint)
					{
						delete oprand;
						return FALSE;
					}
					else
						HasPoint=TRUE;
				}
				if(oprand->m_IsConst && !ISDIGIT(string[i]) && (string[i] != '.'))
				{
					delete oprand;
					return FALSE;
				}
				oprand->m_name[j++] = string[i];
				i++;
			}
			Oprand.push(oprand);
			j = 0;
		}
	}
	return TRUE;
}

[wcjunhua]

boolean CStringResolution::GetOperatorStack(CStack &Operator, char* string)
{
	boolean bRet=TRUE;
	int num = STRLEN(string);
	int i=0;
	int level=0;
	while(i<num)
	{
		if(string[i]=='(')
		{
			level+=LEVELS;
			string[i] = '#';
			i++;
		}
		else if(string[i]==')')
		{
			level-=LEVELS;
			string[i] = '@';
			i++;
		}
		else if(string[i]=='+'||string[i]=='-')
		{
			COperator* op = new COperator();
			op->m_level = level + 5;
			op->m_startIndex=i;
			if(i==0 || string[i-1]=='#')
			{
				op->m_type=UNARY;
				op->m_level += 5;
				if(string[i]=='-')
					op->m_op = OP_NEG;
				else
					op->m_op = OP_POS;
			}
			else
			{
				op->m_type=BINARY;
				if(string[i]=='-')
					op->m_op = OP_SUB;
				else
					op->m_op = OP_ADD;
			}
			Operator.push(op);
			string[i] = '@';
			i++;
		}
		else if(string[i]=='*'||string[i]=='/'||string[i]=='%')
		{
			COperator* op=new COperator();
			op->m_level=level+6;
			if(string[i]=='*')
				op->m_op = OP_MUL;
			else if(string[i]=='/')
				op->m_op = OP_DIV;
			else
				op->m_op = OP_MOD;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			i++;
		}
		else if(string[i]=='^')
		{
			COperator* op=new COperator();
			op->m_level=level+7;
			op->m_op = OP_MMUL;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			i++;
		}
		else if(STR_IsStartBy(&string[i],"and"))
		{
			COperator* op=new COperator();
			op->m_level=level+2;
			op->m_op = OP_AND;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			string[i+2] = '@';
			i+=3;			
		}
		else if(STR_IsStartBy(&string[i],"or"))
		{
			COperator* op=new COperator();
			op->m_level=level+1;
			op->m_op = OP_OR;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			i+=2;			
		}
		else if(STR_IsStartBy(&string[i],"not"))
		{
			COperator* op=new COperator();
			op->m_level=level+9;
			op->m_op = OP_NOT;
			op->m_startIndex=i;
			op->m_type=UNARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			string[i+2] = '@';
			i+=3;			
		}
		else if(STR_IsStartBy(&string[i],">="))
		{
			COperator* op=new COperator();
			op->m_level=level+4;
			op->m_op = OP_GE;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			i+=2;
		}
		else if(STR_IsStartBy(&string[i],"<="))
		{
			COperator* op=new COperator();
			op->m_level=level+4;
			op->m_op = OP_LE;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			i+=2;
		}
		else if(string[i]=='<')
		{
			COperator* op=new COperator();
			op->m_level=level+4;
			op->m_op = OP_LT;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			i+=1;
		}
		else if(string[i]=='>')
		{
			COperator* op=new COperator();
			op->m_level=level+4;
			op->m_op = OP_GT;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			i+=1;
		}
		else if(STR_IsStartBy(&string[i],"<>"))
		{
			COperator* op=new COperator();
			op->m_level=level+3;
			op->m_op = OP_NOTEQUAL;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			i+=2;
		}
		else if(STR_IsStartBy(&string[i],"=="))
		{
			COperator* op=new COperator();
			op->m_level=level+3;
			op->m_op = OP_EQUAL;
			op->m_startIndex=i;
			op->m_type=BINARY;
			Operator.push(op);
			string[i] = '@';
			string[i+1] = '@';
			i+=2;
		}
		else if(string[i]=='=')
		{
			int lastpos = 0;
			COperator* op = (COperator*)Operator.top(); //new COperator();
			if(op)
				lastpos = op->m_startIndex;

			int ii = i-lastpos+1;
			dstname = (char*)MYMALLOC(ii);
			MEMCPY(dstname,&string[lastpos],ii-1);
			ii = STRLEN(string);
			MEMCPY(&string[lastpos],&string[i+1],ii-i-1);
			string[lastpos+ii-i-1] = 0;
			//MEMSET(&string[op->m_startIndex],' ',i-1);
			/*
			op->m_level=level;
			op->m_op = OP_ASSIGN;
			op->m_startIndex=i;
			op->m_type=UNARY;
			Operator.push(op);
			string[i] = '@';
			*/
			
			i = lastpos;
		}
		else
			i++;
	}
	return bRet;
}

double CStringResolution::Computer(CStack &Operator, CStack &Oprand)
{
	AECHAR szstr[16];

	double value = FASSIGN_STR("0.0");
	if(Operator.empty())
	{
		if(Oprand.size()==1)
		{	
			COperand* od=(COperand*)Oprand.top();
			value = FASSIGN_STR(od->m_name);
			delete (od);
			return value;
		}
		else
		{
			while(!Oprand.empty())
			{
				COperand*od=(COperand*)Oprand.top();
				Oprand.pop();
				delete (od);
			}
			return BIGNUMBER;
		}
	}
	CStack tmpOO;
	CStack tmpOD;
	COperator* op=0,*op1=0;
	COperand* oprand=0,*oprand1=0;
	
	op=(COperator*)Operator.top();
	Operator.pop();
	if(!Operator.empty())
		op1=(COperator*)Operator.top();

	while(op1 && (op1->m_level > op->m_level))
	{
		tmpOO.push(op);
		if(op->m_type==BINARY)
		{
			if(!Oprand.empty())
			{
				oprand=(COperand*)Oprand.top();
				Oprand.pop();
				tmpOD.push(oprand);
			}
		}
		op=op1;
		Operator.pop();
		if(!Operator.empty())
			op1=(COperator*)Operator.top();
		else
			op1=0;
	}
	if(op->m_type==UNARY)
	{
		if(Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand=(COperand*)Oprand.top();
		double x=computing(op,oprand);
		FLOATTOWSTR(x,szstr,32);
		WSTRTOSTR(szstr,oprand->m_name,16);		
	}
	else
	{
		if(Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand1=(COperand*)Oprand.top();
		Oprand.pop();
		if(Oprand.empty())
		{
			return BIGNUMBER;
		}
		oprand=(COperand*)Oprand.top();
		double x=computing(op,oprand1,oprand);
		FLOATTOWSTR(x,szstr,32);
		WSTRTOSTR(szstr,oprand->m_name,16);
		delete (oprand1);
	}
	delete (op);
	while(!tmpOO.empty())
	{
		op=(COperator*)tmpOO.top();
		tmpOO.pop();
		Operator.push(op);
	}
	while(!tmpOD.empty())
	{
		oprand=(COperand*)tmpOD.top();
		tmpOD.pop();
		Oprand.push(oprand);
	}
	return Computer(Operator,Oprand);
}

double CStringResolution::computer(double variantValue[], int num)
{
	double value = FASSIGN_STR("0.0");
	
	AECHAR szstr[16];

	int i;
	if(num<m_oprandANum)
	{
		return BIGNUMBER;
	}
	CStack Operator;
	CStack Oprand;

	for(i=0;i<m_operatorNum;i++)
	{
		COperator*op=new COperator;
		*op=m_operator[m_operatorNum-i-1];
		Operator.push(op);
	}
	for(i=0;i<m_oprandNum;i++)
	{
		COperand*od=new COperand;
		*od=m_oprand[m_oprandNum-i-1];
		for(int j=0;j<m_oprandANum;j++)
		{
			if(*od==m_oprandA[j])
			{
				FLOATTOWSTR(variantValue[j],szstr,32);
				WSTRTOSTR(szstr,od->m_name,16);					
			}
		}
		Oprand.push(od);
	}
	value=Computer(Operator,Oprand);

	return value;
}

double CStringResolution::computing(const COperator*op,const COperand*oprand)
{
	double x = FASSIGN_STR(oprand->m_name);
	
	if(op->m_op ==OP_NEG)
	{
		x=-x;
	}
	else if(op->m_op == OP_POS)
	{
		;
	}
	else if(op->m_op == OP_ASSIGN)
	{
		//oprand=(COperand*)Oprand.top();
		//DBGPRINTF("%d,%s",op->m_op,oprand->m_name);
	}
	else if(op->m_op == OP_NOT)
	{
		boolean b = ATOI(oprand->m_name);
		b = !b;
		x = FASSIGN_INT((int)b);
	}
	return x;
}
double CStringResolution::computing(const COperator*op,const COperand*Loprand,const COperand*Roprand)
{
	double x = BIGNUMBER;
	switch(op->m_op)
	{
	case OP_OR:
		{
			int i1 = ATOI(Loprand->m_name);
			int i2 = ATOI(Roprand->m_name);
			x = FASSIGN_INT((int)(i1 || i2));
		}
		break;
	case OP_AND:
		{
			int i1 = ATOI(Loprand->m_name);
			int i2 = ATOI(Roprand->m_name);
			x = FASSIGN_INT((int)(i1 && i2));
		}
		break;
	case OP_EQUAL:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = (FCMP_E(i1,i2));
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_NOTEQUAL:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = !FCMP_E(i1,i2);
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_GT:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = FCMP_G(i1,i2);
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_GE:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = FCMP_GE(i1,i2);
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_LT:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = FCMP_L(i1,i2);
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_LE:
		{
			double i1 = FASSIGN_STR(Loprand->m_name);
			double i2 = FASSIGN_STR(Roprand->m_name);
			boolean i = FCMP_LE(i1,i2);
			x = FASSIGN_INT((int)i);
		}
		break;
	case OP_ADD:
		x= FADD(FASSIGN_STR(Loprand->m_name),FASSIGN_STR(Roprand->m_name));
		break;
	case OP_SUB:
		x= FSUB(FASSIGN_STR(Loprand->m_name),FASSIGN_STR(Roprand->m_name));
		break;
	case OP_MUL:
		x=FMUL(FASSIGN_STR(Loprand->m_name),FASSIGN_STR(Roprand->m_name));
		break;
	case OP_DIV:
		{
			double d1 = FASSIGN_STR(Loprand->m_name);
			double d2 = FASSIGN_STR(Roprand->m_name);
			if(!ISZERO(d2))
			{
				x = FDIV(d1,d2);
			}
		}
		break;
	default:
		break;
	}
	return x;
}

[wcjunhua]

// StringResolution.h
//
//////////////////////////////////////////////////////////////////////
#if !defined(_STRINGRESOLUTION_H_)
#define _STRINGRESOLUTION_H_

#include "aee.h"
#include "aeestdlib.h"

#include "../apputil.h"

#define LEVELS 55
#define DERROR FASSIGN_STR("0.0000001")
#define BIGNUMBER FASSIGN_STR("0.0")
#define UNARY 0
#define BINARY 1


#define OP_OR 1
#define OP_AND 2
#define OP_EQUAL 3
#define OP_NOTEQUAL 4
#define OP_GT 5
#define OP_GE 6
#define OP_LT 7
#define OP_LE 8
#define OP_ADD 9
#define OP_SUB 10
#define OP_MUL 11
#define OP_DIV 12
#define OP_MOD 13
#define OP_MMUL 14
#define OP_FUNC 15
#define OP_NOT 16
#define OP_NEG 17
#define OP_POS 18
#define OP_ASSIGN 19

//操作符类
class COperator  
{
public:
	COperator();
	~COperator();	
    void* operator new (size_t iSize)
    {
        return MEMSET(MALLOC(iSize),0,iSize);
    }
    void operator delete (void* p)
    {
        FREE(p);
    }	
	uint16 m_level;	// = 0
					// or - 1
					// and - 2
					// == <> - 3
					// > >= < <= 4
					// +,-  5
					// *,/,% 6
					// ^  7
					// function 8
					// not 9
					// -,+ 10
	byte m_op;		//		
	byte m_type;	//0--单目运算, 1--双目运算
	uint16 m_startIndex;	// start index which in formula
};

class COperand  
{
public:
	COperand();
	~COperand();
	
    void* operator new (size_t iSize)
    {
         return MEMSET(MALLOC(iSize),0,iSize);
    }
    void operator delete (void* p)
    {
        FREE(p);
    }
	boolean operator ==(const COperand&od);	//judge two operand are equal or not
	
	uint16 m_startIndex;	//start index which in formula
	boolean m_IsConst;		//TRUE when it is digital, FALSE otherwise
	char m_name[17];		//digital string or variant name
};

//堆栈
class CStack
{
public:
	CStack();
	~CStack();
    void* operator new (size_t iSize)
    {
         return MEMSET(MALLOC(iSize),0,iSize);
    }
    void operator delete (void* p)
    {
        FREE(p);
    }

	uint16 size();
	boolean empty();
	void* top();
	void* pop();
	void push(void* v);
private:
	CBWList* datalist;
};

class CStringResolution
{
public:
    void* operator new (size_t iSize)
    {
        return MEMSET(MALLOC(iSize),0,iSize);
    }
    void operator delete (void* p)
    {
        FREE(p);
    }
	void Destroy();
	double computer(double variantValue[],int num);
	void SetFormula(char*formula);
	CStringResolution(char*formula=0);
	int GetVariantCount(){return m_oprandANum;}
	char* GetVariantName(int index);
	~CStringResolution();
public:
	uint16 m_oprandNum;//operand number
	uint16 m_oprandANum;//variant number
	uint16 m_operatorNum;//operator number
	
	char* dstname;	//赋值变量名
	char* m_formula;	//formula string
	COperator *m_operator;//pointer points to operators set
	COperand *m_oprand;//pointer points to operands set
	COperand *m_oprandA;//pointer points to variants set
	
	boolean GetStack(CStack &Op, CStack &Od);//get operators stack and operands stack.
	boolean Initialize();//initialize variant member by m_formula.
	double Computer(CStack &Operator, CStack &Oprand);//computing by stack.
	boolean EmptyStack(CStack& st,boolean flag);//empty stack

	boolean GetOperandStack(CStack &Oprand,char *string);    //get operator stack in formula.
	boolean GetOperatorStack(CStack &Operator,char *string); //get operand stack after GetOperandStack.

	double computing(const COperator *op,const COperand *oprand);//unary computing
	double computing(const COperator *op,const COperand *Loprand,const COperand *Roprand);//binary computing
};

extern boolean ISZERO(double d);

#endif

[冰思雨]

真佩服，这么多的代码啊。
楼主为啥不用JDK1.6呢？里面好像有个可以运行脚本的功能。
貌似还支持JavaScript呢，当然，四则运算根式轻而易举滴。

[冰思雨]

楼主的这个代码，也不知道是怎么用，我给你人工转换了。
就是不知道运行结果如何，因为，不知道用法。一共四个类，每个类一个文件。

public class COperand {

	public int m_startIndex =0; //start index which in formula
	public boolean m_IsConst =false; //TRUE when it is digital, FALSE otherwise
	public String m_name ; //digital string or variant name
	
	@Override
	public boolean equals(Object obj) {
		if(obj!=null && obj instanceof COperand){
			COperand od = (COperand)obj;
			return (m_IsConst&&od.m_IsConst) && (m_name.equals(od.m_name));
		}
		return  false;
	}
	
	
}

public class COperator {
	public int m_level; // = 0
	// or - 1
	// and - 2
	// == <> - 3
	// > >= < <= 4
	// +,-  5
	// *,/,% 6
	// ^  7
	// function 8
	// not 9
	// -,+ 10
	public byte m_op; //        
	public byte m_type; //0--单目运算, 1--双目运算
	public int m_startIndex; // start index which in formula
	
	public static final int LEVELS = 55;//
	
	public static final int UNARY = 0;
	public static final int BINARY = 1;
	
	public static final byte OP_OR = 1;// or - 1
	public static final byte OP_AND =2;// and - 2
	public static final byte OP_EQUAL =3;// == <> - 3
	public static final byte OP_NOTEQUAL =4;// > >= < <= 4
	public static final byte OP_GT =5;// +,-  5
	public static final byte OP_GE =6;// *,/,% 6
	public static final byte OP_LT =7;// ^  7
	public static final byte OP_LE =8;// function 8
	public static final byte OP_ADD =9;// not 9
	public static final byte OP_SUB =10;// -,+ 10
	public static final byte OP_MUL =11;
	public static final byte OP_DIV =12;
	public static final byte OP_MOD =13;
	public static final byte OP_MMUL =14;
	public static final byte OP_FUNC =15;
	public static final byte OP_NOT =16;
	public static final byte OP_NEG =17;
	public static final byte OP_POS =18;
	public static final byte OP_ASSIGN =19;
}

import java.util.LinkedList;

public class CStack {
	private LinkedList  datalist = new LinkedList();
	public int size(){
		return datalist.size();
	}
	public boolean empty(){
		return datalist.isEmpty();
	}
	public Object top(){
		return datalist.getLast();
	}
	public Object pop(){
		return datalist.removeLast();
	}
	public void push(Object v){
		datalist.addLast(v);
	}
}

[冰思雨]

最后一个文件太长了。分3个贴吧。

/**
 *CStringResolution.java (1/3)
 */
public class CStringResolution {
	public static final boolean TRUE = true;
	public static final boolean FALSE = false;

	public static final double DERROR = 0.0000001d;// 浮点数的精度。
	public static final double BIGNUMBER = 0.0d;

	static int ATOI(String iStr) {return Integer.parseInt(iStr);}
	static boolean ISDIGIT(char ch){return Character.isDigit(ch); }
	static boolean ISZERO(double d) {return d < DERROR  || d > - DERROR;}
	static boolean STR_IsStartBy(char [] str,int index, final String head) {return new String(str,index,str.length-index-1).startsWith(head);}
	static int STRLEN(char [] string){
		int len = 0;
		while(string[len++]!=0);
		return len;
	}
	static double FASSIGN_STR(String str){return Double.parseDouble(str);}
	static double FASSIGN_INT(int i){return new Integer(i).doubleValue();}
	static double FASSIGN_INT(boolean b){return b?1d:0d;}
	static double FDIV(double d1, double d2) {return d1/d2;}
	static double FMUL(double d1, double d2) {return d1*d2;}
	static double FSUB(double d1, double d2) {return d1-d2;}
	static double FADD(double d1, double d2) {return d1+d2;}
	static boolean FCMP_LE(double d1, double d2) {return Double.compare(d1, d2)<=0;}
	static boolean FCMP_L(double d1, double d2) {return Double.compare(d1, d2)<0;}
	static boolean FCMP_GE(double d1, double d2) {return Double.compare(d1, d2)>=0;}
	static boolean FCMP_G(double d1, double d2) {return Double.compare(d1, d2)>0;}
	static boolean FCMP_E(double d1, double d2) {return Double.compare(d1, d2)==0;}
	
	public int m_oprandNum;// operand number
	public int m_oprandANum;// variant number
	public int m_operatorNum;// operator number

	public char [] dstname; // 赋值变量名
	public String m_formula; // formula string
	public COperator m_operator[];// pointer points to operators set
	public COperand m_oprand [];// pointer points to operands set
	public COperand m_oprandA [];// pointer points to variants set

	public CStringResolution(String formula)
	{
		m_oprandNum=0;m_oprandANum=0;m_operatorNum=0;
		m_operator=null;
		m_oprand=null;
		m_oprandA=null;
		m_formula = null;
		dstname = null;
		if(formula!=null)
		{
			m_formula = formula.toUpperCase();
			Initialize();
		}
	}
	
	public String GetVariantName(int index){
		if(index >=0 && index < m_oprandANum)
		{
			return m_oprandA[index].m_name;
		}
		return null;
	}
	
	public void SetFormula(String formula){
		if(formula==null)return;
		m_formula = formula.toUpperCase();
		m_operator=null;
		m_oprand = null;
		m_oprandA = null;
		m_oprandNum=0;m_oprandANum=0;m_operatorNum=0;
		Initialize();
	}
	
	// get operators stack and operands stack.
	public boolean GetStack(CStack Operator, CStack Oprand){
		// boolean GetStack(CStack &Op, CStack &Od);//这个方法不知能否实现
		boolean bRet=TRUE;
		EmptyStack(Operator,TRUE);
		EmptyStack(Oprand,FALSE);
		bRet=bRet && GetOperatorStack(Operator,m_formula);
		bRet=bRet && GetOperandStack(Oprand,m_formula);
		return bRet;
	}
	
	public boolean EmptyStack(CStack stack, boolean flag){// empty stack
		// boolean EmptyStack(CStack& st, boolean flag);//这个方法不知能否实现
		while(!stack.empty())
		{
			Object op = stack.pop();
			op = null;
		}
		return TRUE;
	}
	
	// initialize variant member by m_formula.
	public boolean Initialize(){
		boolean bRet=FALSE;
		CStack Op = new CStack();
		CStack Od = new CStack();

		bRet=GetStack(Op,Od);
		if(!bRet)
		{
			EmptyStack(Op,TRUE);
			EmptyStack(Od,FALSE);
			return FALSE;
		}

		m_oprandNum = Od.size();
		m_operatorNum = Op.size();

		if(m_operatorNum!=0)
		m_operator = new COperator[m_operatorNum];
		if(m_oprandNum!=0)
		m_oprand = new COperand[m_oprandNum];

		int i;
		for(i=0;i <m_operatorNum;i++)
		{
			COperator op = (COperator)Op.top();
			m_operator[m_operatorNum-i-1] = op;
			Op.pop();
			op=null;
		}
		for(i=0;i <m_oprandNum;i++)
		{
			COperand od=(COperand)Od.top();
			m_oprand[m_oprandNum-i-1]=od;
			Od.pop();
			od=null;
		}
		m_oprandA =new COperand[m_oprandNum];
		boolean IsIn=FALSE;
		for(i=0;i <m_oprandNum;i++)
		{
			for(int j=0;j <m_oprandANum;j++)
			{
				if(m_oprand[i].equals(m_oprandA[j]))
				{
					IsIn=TRUE;
					break;
				}
			}
			if(!IsIn&&!m_oprand[i].m_IsConst)
			{
				m_oprandA[m_oprandANum]=m_oprand[i];
				m_oprandANum++;
			}
			IsIn=FALSE;
		}
		return TRUE;
	}// boolean Initialize();
	
	// get operator stack in formula.
	public boolean GetOperandStack(CStack Oprand, String string){ 
		// boolean GetOperatorStack(CStack &Operator, char *string);//这个方法不知能否实现
		int i=0;
		int num = string.length();
		while(i <num)
		{
			if(string.charAt(i)== '#'  || string.charAt(i)== '@'  || string.charAt(i)== ' '  || string.charAt(i)== '\t')
				i++;
			else
			{
				COperand oprand = new COperand();
				if(ISDIGIT(string.charAt(i)))
					oprand.m_IsConst=TRUE;
				oprand.m_startIndex=i;
				boolean HasPoint=FALSE;
				while(i < num && string.charAt(i) != '#' && string.charAt(i) != '@')
				{
					if(string.charAt(i)== '.')
					{
						if(HasPoint)
						{
							oprand = null;
							return FALSE;
						}
						else
							HasPoint=TRUE;
					}
					if(oprand.m_IsConst && !ISDIGIT(string.charAt(i)) && (string.charAt(i) != '.'))
					{
						oprand=null;
						return FALSE;
					}
					oprand.m_name += string.charAt(i);
					i++;
				}
				Oprand.push(oprand);
			}
		}
		return TRUE;
	}

[preferwo]

/*
	 * CStringResolution.java (2/3)
	 */

	public boolean GetOperatorStack(CStack Operator, String string){
		char buff [] = new char[string.length()];
		string.getChars(0, string.length(), buff, 0);
		return GetOperatorStack(Operator, buff);
	}
	// get operand stack after GetOperandStack.
	public boolean GetOperatorStack(CStack Operator, char [] string){
		//boolean GetOperatorStack(CStack &Operator, char *string);//这个方法不知能否实现
		boolean bRet=TRUE;
		int num = STRLEN(string);
		int i=0;
		int level=0;
		while(i<num)
		{
			if(string[i]=='(')
			{
				level+=COperator.LEVELS;
				string[i] = '#';
				i++;
			}
			else if(string[i]==')')
			{
				level-=COperator.LEVELS;
				string[i] = '@';
				i++;
			}
			else if(string[i]=='+'||string[i]=='-')
			{
				COperator op = new COperator();
				op.m_level = level + 5;
				op.m_startIndex=i;
				if(i==0 || string[i-1]=='#')
				{
					op.m_type=COperator.UNARY;
					op.m_level += 5;
					if(string[i]=='-')
						op.m_op = COperator.OP_NEG;
						else
							op.m_op = COperator.OP_POS;
				}
				else
				{
					op.m_type=COperator.BINARY;
					if(string[i]=='-')
						op.m_op = COperator.OP_SUB;
						else
							op.m_op = COperator.OP_ADD;
				}
				Operator.push(op);
				string[i] = '@';
				i++;
			}
			else if(string[i]=='*'||string[i]=='/'||string[i]=='%')
			{
				COperator op=new COperator();
				op.m_level=level+6;
				if(string[i]=='*')
					op.m_op = COperator.OP_MUL;
					else if(string[i]=='/')
						op.m_op = COperator.OP_DIV;
						else
							op.m_op = COperator.OP_MOD;
							op.m_startIndex=i;
							op.m_type=COperator.BINARY;
							Operator.push(op);
							string[i] = '@';
							i++;
			}
			else if(string[i]=='^')
			{
				COperator op=new COperator();
				op.m_level=level+7;
				op.m_op = COperator.OP_MMUL;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				i++;
			}
			else if(STR_IsStartBy(string,i,"and"))
			{
				COperator op=new COperator();
				op.m_level=level+2;
				op.m_op = COperator.OP_AND;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				string[i+2] = '@';
				i+=3;
			}
			else if(STR_IsStartBy(string,i,"or"))
			{
				COperator op=new COperator();
				op.m_level=level+1;
				op.m_op = COperator.OP_OR;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				i+=2;
			}
			else if(STR_IsStartBy(string,i,"not"))
			{
				COperator op=new COperator();
				op.m_level=level+9;
				op.m_op = COperator.OP_NOT;
				op.m_startIndex=i;
				op.m_type=COperator.UNARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				string[i+2] = '@';
				i+=3;
			}
			else if(STR_IsStartBy(string,i,">="))
			{
				COperator op=new COperator();
				op.m_level=level+4;
				op.m_op = COperator.OP_GE;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				i+=2;
			}
			else if(STR_IsStartBy(string,i,"<="))
			{
				COperator op=new COperator();
				op.m_level=level+4;
				op.m_op = COperator.OP_LE;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				i+=2;
			}
			else if(string[i]=='<')
			{
				COperator op=new COperator();
				op.m_level=level+4;
				op.m_op = COperator.OP_LT;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				i+=1;
			}
			else if(string[i]=='>')
			{
				COperator op=new COperator();
				op.m_level=level+4;
				op.m_op = COperator.OP_GT;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				i+=1;
			}
			else if(STR_IsStartBy(string,i,"<>"))
			{
				COperator op=new COperator();
				op.m_level=level+3;
				op.m_op = COperator.OP_NOTEQUAL;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				i+=2;
			}
			else if(STR_IsStartBy(string,i,"=="))
			{
				COperator op=new COperator();
				op.m_level=level+3;
				op.m_op = COperator.OP_EQUAL;
				op.m_startIndex=i;
				op.m_type=COperator.BINARY;
				Operator.push(op);
				string[i] = '@';
				string[i+1] = '@';
				i+=2;
			}
			else if(string[i]=='=')
			{
				int lastpos = 0;
				COperator op = (COperator)Operator.top(); //new COperator();
				if(op!=null)
					lastpos = op.m_startIndex;
		
					int ii = i-lastpos+1;
					dstname = new char[ii];
					System.arraycopy(string, lastpos, dstname, 0, ii-1);
					//MEMCPY(dstname,&string[lastpos],ii-1);
					ii = STRLEN(string);
					System.arraycopy(string, i+1, string, lastpos, ii-i-1);
					//MEMCPY(&string[lastpos],&string[i+1],ii-i-1);
					string[lastpos+ii-i-1] = 0;
					//MEMSET(&string[op->m_startIndex],' ',i-1);
					/*
					 op->m_level=level;
					 op->m_op = OP_ASSIGN;
					 op->m_startIndex=i;
					 op->m_type=UNARY;
					 Operator.push(op);
					 string[i] = '@';
					 */
		
						i = lastpos;
				}
				else
					i++;
			}
			return bRet;
		}

[冰思雨]

/**
 *CStringResolution.java (3/3)
 */
	// computing by stack.
	public double Computer(CStack Operator, CStack Oprand){
		//double Computer(CStack &Operator, CStack &Oprand);//这个方法不知能否实现
		char szstr []= new char[16];
		double value = FASSIGN_STR("0.0");
		if(Operator.empty())
		{
			if(Oprand.size()==1)
			{
				COperand od=(COperand)Oprand.top();
				value = FASSIGN_STR(od.m_name);
				od=null;
				return value;
			}
			else
			{
				while(!Oprand.empty())
				{
					COperand od=(COperand)Oprand.top();
					Oprand.pop();
					od=null;
				}
				return BIGNUMBER;
			}
		}
		CStack tmpOO = new CStack();
		CStack tmpOD = new CStack();
		COperator op=null,op1=null;
		COperand oprand=null,oprand1=null;

		op=(COperator)Operator.top();
		Operator.pop();
		if(!Operator.empty())
		op1=(COperator)Operator.top();

		while(op1!=null && (op1.m_level > op.m_level))
		{
			tmpOO.push(op);
			if(op.m_type==COperator.BINARY)
			{
				if(!Oprand.empty())
				{
					oprand=(COperand)Oprand.top();
					Oprand.pop();
					tmpOD.push(oprand);
				}
			}
			op=op1;
			Operator.pop();
			if(!Operator.empty())
			op1=(COperator)Operator.top();
			else
			op1=null;
		}
		if(op.m_type==COperator.UNARY)
		{
			if(Oprand.empty())
			{
				return BIGNUMBER;
			}
			oprand=(COperand)Oprand.top();
			double x= computing(op,oprand);
			oprand.m_name = String.valueOf(x);
//			FLOATTOWSTR(x,szstr,32);
//			WSTRTOSTR(szstr,oprand.m_name,16);
		}
		else
		{
			if(Oprand.empty())
			{
				return BIGNUMBER;
			}
			oprand1=(COperand)Oprand.top();
			Oprand.pop();
			if(Oprand.empty())
			{
				return BIGNUMBER;
			}
			oprand=(COperand)Oprand.top();
			double x= computing(op,oprand1,oprand);
			oprand.m_name = String.valueOf(x);
//			FLOATTOWSTR(x,szstr,32);
//			WSTRTOSTR(szstr,oprand.m_name,16);
			oprand1=null;
		}
		op=null;
		while(!tmpOO.empty())
		{
			op=(COperator)tmpOO.top();
			tmpOO.pop();
			Operator.push(op);
		}
		while(!tmpOD.empty())
		{
			oprand=(COperand)tmpOD.top();
			tmpOD.pop();
			Oprand.push(oprand);
		}
		return Computer(Operator,Oprand);
	}

	public double computer(double variantValue[], int num){
		//double computer(double variantValue[], int num);
		double value = FASSIGN_STR("0.0");
		char szstr [] = new char[16];
		int i;
		if(num<m_oprandANum)
		{
			return BIGNUMBER;
		}
		CStack Operator = new CStack();
		CStack Oprand = new CStack();
		for(i=0;i<m_operatorNum;i++)
		{
			COperator op=new COperator();
			op=m_operator[m_operatorNum-i-1];
			Operator.push(op);
		}
		for(i=0;i<m_oprandNum;i++)
		{
			COperand od=new COperand();
			od=m_oprand[m_oprandNum-i-1];
			for(int j=0;j<m_oprandANum;j++)
			{
				if(od.equals(m_oprandA[j]))
				{
					od.m_name=String.valueOf(od.m_name);
//					FLOATTOWSTR(variantValue[j],szstr,32);
//					WSTRTOSTR(szstr,od.m_name,16);
				}
			}
			Oprand.push(od);
		}
		value=Computer(Operator,Oprand);
		return value;
	}
	
	//// unary computing
	public double computing(final COperator op, final COperand oprand){
		//double computing(const COperator *op, const COperand *oprand);
		double x = FASSIGN_STR(oprand.m_name);

		if(op.m_op ==COperator.OP_NEG)
		{
			x=-x;
		}
		else if(op.m_op == COperator.OP_POS)
		{
			;
		}
		else if(op.m_op == COperator.OP_ASSIGN)
		{
			//oprand=(COperand*)Oprand.top();
			//DBGPRINTF("%d,%s",op->m_op,oprand->m_name);
		}
		else if(op.m_op == COperator.OP_NOT)
		{
			int b = ATOI(oprand.m_name)==0?1:0;
//			boolean b = ATOI(oprand.m_name);
//			b = !b;
			x = FASSIGN_INT((int)b);
		}
		return x;
	}
	
	
	//// binary computing
	public double computing(final COperator op, final COperand Loprand,final COperand Roprand){
		//double computing(const COperator *op, const COperand *Loprand, const COperand *Roprand);
		double x = BIGNUMBER;
		switch(op.m_op)
		{
			case COperator.OP_OR:
			{
				int i1 = ATOI(Loprand.m_name);
				int i2 = ATOI(Roprand.m_name);
				x = FASSIGN_INT((i1!=0 || i2!=0));
//				x = FASSIGN_INT((int)(i1 || i2));
			}
			break;
			case COperator.OP_AND:
			{
				int i1 = ATOI(Loprand.m_name);
				int i2 = ATOI(Roprand.m_name);
				x = FASSIGN_INT((i1!=0 && i2!=0));
			}
			break;
			case COperator.OP_EQUAL:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = (FCMP_E(i1,i2));
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_NOTEQUAL:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = !FCMP_E(i1,i2);
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_GT:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = FCMP_G(i1,i2);
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_GE:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = FCMP_GE(i1,i2);
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_LT:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = FCMP_L(i1,i2);
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_LE:
			{
				double i1 = FASSIGN_STR(Loprand.m_name);
				double i2 = FASSIGN_STR(Roprand.m_name);
				boolean i = FCMP_LE(i1,i2);
				x = FASSIGN_INT(i);
			}
			break;
			case COperator.OP_ADD:
			x= FADD(FASSIGN_STR(Loprand.m_name),FASSIGN_STR(Roprand.m_name));
			break;
			case COperator.OP_SUB:
			x= FSUB(FASSIGN_STR(Loprand.m_name),FASSIGN_STR(Roprand.m_name));
			break;
			case COperator.OP_MUL:
			x=FMUL(FASSIGN_STR(Loprand.m_name),FASSIGN_STR(Roprand.m_name));
			break;
			case COperator.OP_DIV:
			{
				double d1 = FASSIGN_STR(Loprand.m_name);
				double d2 = FASSIGN_STR(Roprand.m_name);
				if(!ISZERO(d2))
				{
					x = FDIV(d1,d2);
				}
			}
			break;
			default:
			break;
		}
		return x;
	}
	
	public int GetVariantCount() {
		return m_oprandANum;
	}
	
	protected void finalize() throws Throwable {
		m_operator=null;
		m_oprand=null;
		m_oprandA=null;
		m_formula=null;
		dstname=null;
	}
}

[jayklx]

[Quote=引用 6 楼 bao110908 的回复:]
有兴趣的话看看这个帖子
http://topic.csdn.net/u/20081011/11/c69b34f6-7605-44a4-918b-a4bed78e8654.html

让人帮你改这段代码，那是不可能的，要么谁实在是闲得发慌了。
[/Quote]还真有人闲的发慌了。。。

[wcjunhua]

跪求高人，只需要改下语言结构，大体的算法不用改

[火龙果被占用了]

改这段代码？

不要说改了，光看懂就得花半天时间！

[火龙果被占用了]

有兴趣的话看看这个帖子
http://topic.csdn.net/u/20081011/11/c69b34f6-7605-44a4-918b-a4bed78e8654.html

让人帮你改这段代码，那是不可能的，要么谁实在是闲得发慌了。

[wcjunhua]

这是个高人啊，谢谢帮我改代码的大哥，真的，跪谢，太感谢了，不晓得用什么语言来表达我对你的谢意