// Parse.cpp: implementation of the CParse class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "24points.h"
#include "Parse.h"

#include <stack>

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CParse::CParse()
{

}

CParse::~CParse()
{

}
char CParse::error_string[7][255]={
	"括號錯誤。",
	"操作符錯誤。",
	"操作數錯誤。",
	"分母為0。",
	"其他錯誤。",
	"無錯誤。",
	"除不盡。"
};

int CParse::Precede(char a,char b)
{
	static char PrecedeState[7][7]={
		1, 1,-1,-1,-1, 1, 1,
		1, 1,-1,-1,-1, 1, 1,
		1, 1, 1, 1,-1, 1, 1,
		1, 1, 1, 1,-1, 1, 1,
		-1,-1,-1,-1,-1, 0,-2,
		1, 1, 1, 1,-2, 1, 1,
		-1,-1,-1,-1,-1,-2, 0};
	char op[]="+-*/()#";
	int i=0,j=0;
	while(*(op+i)!=a&&i<7)i++;
	while(*(op+j)!=b&&j<7)j++;
	if(i>=7||j>=7)
		return -2;
	return PrecedeState[i][j];
}
int CParse::getNumber(char* formula,int&s)
{
	char str[25]={0};
	int i=s;
	while(isdigit(formula[i]))
		str[i-s]=formula[i],i++;
	s=i;
	return atoi(str);
}
int CParse::Operator(int a,char op,int b)
{
	switch(op)
	{
	case '+':
		return a+b;
		break;
	case '-':
		return a-b;
		break;
	case '*':
		return a*b;
		break;
	case '/':
		if(b==0)
			m_erro_type.push_back(DIVIDERZERO);
		else if(a%b)
			m_erro_type.push_back(NOTFACTOR);
		else
			return a/b;
		break;
	default:
		m_erro_type.push_back(OPERATORERROR);
		break;
	}
	return 0;
}
int CParse::ExpressionReduce(char*str)
{
	if(!ParanCrect(str))
	{
		m_erro_type.push_back(PARENTHESESERROR);
		return -9999;
	}
	while(*str==' ')str++;
	std::stack<int> oprnd;
	std::stack<char> optr;
	str[strlen(str)]='#';
	str[strlen(str)]=0;
	int index=0;
	int a=1,b=1;
	char op;
	int value=999999;
	optr.push('#');
	int char_type=-1;
	while(index<strlen(str))
	{
		if(isdigit(str[index]))
		{
			if(char_type==1&&str[index-1]==')')
				m_erro_type.push_back(OPERATORERROR);
			char_type=0;
			oprnd.push(getNumber(str,index));
		}
		else
		{
			if(char_type==0&&str[index]=='(')
				m_erro_type.push_back(OPERATORERROR);
			if(char_type==1&&str[index]=='('&&str[index-1]==')')
				m_erro_type.push_back(OPERATORERROR);
			char_type=1;
			if(optr.empty())
			{
				m_erro_type.push_back(OPERATORERROR);
				return 0;
			}
			switch(Precede(optr.top(),str[index]))
			{
			case -1:
				optr.push(str[index]),index++;
				break;
			case 0:
				if(optr.empty())
					m_erro_type.push_back(PARENTHESESERROR);
				else
					optr.pop(),index++;
				break;
			case 1:
				if(optr.empty())
					m_erro_type.push_back(OPERATORERROR);
				else
					op=optr.top(),optr.pop();
				if(oprnd.empty())
					m_erro_type.push_back(OPERANDERROR);
				else
					b=oprnd.top(),oprnd.pop();
				if(oprnd.empty())
					m_erro_type.push_back(OPERANDERROR);
				else
					a=oprnd.top(),oprnd.pop();
				oprnd.push(Operator(a,op,b));
				break;
			default:
				m_erro_type.push_back(ORTHERERROR);
				break;
			}
		}
	}
	if(oprnd.empty()||oprnd.size()>1)
		m_erro_type.push_back(OPERANDERROR);
	else 
		value=oprnd.top();
	while(!oprnd.empty())oprnd.pop();
	while(!optr.empty())optr.pop();
	str[strlen(str)-1]=0;
	if(m_erro_type.size())
		return -99999;
	return value;
}
void CParse::get_error_info(std::vector<char*> &strarray)
{
	std::vector<enum _error_enum>::iterator it;
	for(it=m_erro_type.begin();it!=m_erro_type.end();it++)
		strarray.push_back(error_string[*it]);
}

BOOL CParse::ParanCrect(const char *str)
{
	std::stack<char> s;
	int i=0;
	while(i<strlen(str))
	{
		if(str[i]=='(')
			s.push(str[i]);
		if(str[i]==')')
		{
			if(s.empty())
				return FALSE;
			s.pop();
		}
		i++;
	}
	if(!s.empty())
		return FALSE;
	return TRUE;
}