#include "../BasicCompiler_Common/common.h"

#ifdef _AMD64_
#include "../BasicCompiler64/opcode.h"
#else
#include "../BasicCompiler32/opcode.h"
#endif

double dbl_stack[255];
_int64 i64stack[255];

BOOL IsJudgMark(char *Command,int p){
	if(Command[p]==1){
		if(Command[p+1]==ESC_AND) return 1;
		if(Command[p+1]==ESC_OR) return 1;
		if(Command[p+1]==ESC_XOR) return 1;
		if(Command[p+1]==ESC_NOT) return 1;
	}
	return 0;
}
BOOL IsNumCalcMark(char *Command,int p){
	if(Command[p]=='^'||Command[p]=='*'||Command[p]=='/'||Command[p]=='\\'||
		(Command[p]==1&&Command[p+1]==ESC_MOD)||Command[p]=='+'||Command[p]=='-'||
		Command[p]=='='||Command[p]=='<'||Command[p]=='>'||
		IsJudgMark(Command,p)||
		(Command[p]==1&&Command[p+1]==ESC_AS)) return 1;
	return 0;
}
BOOL IsNumCalcMark_Back(char *Command,int p){
	if(p==0){
		if(Command[p]=='^'||Command[p]=='*'||Command[p]=='/'||Command[p]=='\\'||
			Command[p]=='+'||Command[p]=='-'||
			Command[p]=='='||Command[p]=='<'||Command[p]=='>') return 1;
	}
	else{
		if(Command[p]=='^'||Command[p]=='*'||Command[p]=='/'||Command[p]=='\\'||
			(Command[p-1]==1&&Command[p]==ESC_MOD)||Command[p]=='+'||Command[p]=='-'||
			Command[p]=='='||Command[p]=='<'||Command[p]=='>'||
			IsJudgMark(Command,p-1)||
			(Command[p-1]==1&&Command[p]==ESC_AS)) return 1;
	}
	return 0;
}
BOOL IsStrCalcMark(char c){
	if(c=='+'||c=='&') return 1;
	return 0;
}
BOOL IsExponent(char *Command,int p){
	int i,sw;
	for(i=p-2,sw=FALSE;i>=0;i--){
		if(Command[i]>='0'&&Command[i]<='9') sw=TRUE;
		if(!((Command[i]>='0'&&Command[i]<='9')||Command[i]=='.')){
			if((IsNumCalcMark(Command,i)||Command[i]=='('||Command[i]==')')&&sw) return TRUE;
			return FALSE;
		}
		if(i==0&&sw) return TRUE;
	}
	return FALSE;
}

int CompStr(char *str1,int len1,char *str2,int len2){
	int i,len;

	if(len1<len2) len=len1;
	else len=len2;

	for(i=0;i<len;i++){
		if((unsigned char *)str1[i]>(unsigned char *)str2[i]) return 1;
		else if((unsigned char *)str1[i]<(unsigned char *)str2[i]) return -1;
	}
	if(len1>len2) return 1;
	else if(len1<len2) return -1;
	return 0;
}
void TypeErrorCheck(_int64 *stack,int sp,long calc){
	extern int cp;
	if(sp==0||calc==0) return;
	if(sp==1){
		if(stack[0]){
			SetError(9,NULL,cp);
			return;
		}
		return;
	}
	if(CALC_PE<=calc&&calc<=CALC_Q||calc==CALC_ADDITION){
		//文字列演算が可能な演算子
		if((stack[sp-2]&&stack[sp-1]==0)||(stack[sp-2]==0&&stack[sp-1])){
			SetError(9,NULL,cp);
			return;
		}
	}
	else{
		//文字列演算ができない演算子
		if(stack[sp-2]||stack[sp-1]){
			SetError(9,NULL,cp);
			return;
		}
	}
}


int GetLiteralIndex(_int64 i64data){
	if(i64data==0) return LITERAL_NULL;
	else if(-128<=i64data&&i64data<0) return LITERAL_M128_0;
	else if(0<i64data&&i64data<256) return LITERAL_0_255;
	else if(-32768<=i64data&&i64data<0) return LITERAL_M32768_0;
	else if(0<i64data&&i64data<65536) return LITERAL_0_65535;
	else if(i64data<0) return LITERAL_OTHER_MINUS;
	return LITERAL_OTHER_PLUS;
}


int NeutralizationType(int type1,LONG_PTR index1,int type2,LONG_PTR index2){

	if(type1==DEF_DOUBLE||type2==DEF_DOUBLE) return DEF_DOUBLE;
	if(type1==DEF_SINGLE||type2==DEF_SINGLE) return DEF_SINGLE;

	int size1,size2;
	size1=GetTypeSize(type1,index1);
	size2=GetTypeSize(type2,index2);
	if(size1<size2){
		size1=size2;
	}
	else if(type1==type2) return type1;

	if(IsPtrType(type1)||IsPtrType(type2)){
		if(IsPtrType(type1)) return type1;
		else return type2;
	}


	/////////////////////////////
	// 片方がリテラル値の場合
	// ※柔軟に符号を除去する
	/////////////////////////////
	if(IsSignedType(type1)&&IS_POSITIVE_LITERAL(index1)&&
		IsSignedType(type2)==0){
		type1=GetUnsignedType(type1);
	}
	if(IsSignedType(type1)==0&&
		IsSignedType(type2)&&IS_POSITIVE_LITERAL(index2)){
		type2=GetUnsignedType(type2);
	}


	if(IsSignedType(type1)||IsSignedType(type2)){
		//符号あり
		if(size1==sizeof(char))		return DEF_CHAR;
		if(size1==sizeof(short))	return DEF_INTEGER;
		if(size1==sizeof(long))		return DEF_LONG;
		if(size1==sizeof(_int64))	return DEF_INT64;
	}
	else{
		//符号なし
		if(size1==sizeof(char))		return DEF_BYTE;
		if(size1==sizeof(short))	return DEF_WORD;
		if(size1==sizeof(long))		return DEF_DWORD;
		if(size1==sizeof(_int64))	return DEF_QWORD;
	}

	extern int cp;
	SetError(300,NULL,cp);
	return 0;
}

void StaticTwoTerm(int idCalc,int *type_stack,LONG_PTR *index_stack,int *pStackPointer,int BaseType){
	int sp,AnswerType;

	sp=*pStackPointer;
 
	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);

	if(IsRealNumberType(BaseType)&&idCalc==CALC_QUOTIENT) AnswerType=BaseType;

	if(IsRealNumberType(AnswerType)){
		///////////////
		// 実数演算
		///////////////

		if(IsWholeNumberType(type_stack[sp-2])) dbl_stack[sp-2]=(double)i64stack[sp-2];
		if(IsWholeNumberType(type_stack[sp-1])) dbl_stack[sp-1]=(double)i64stack[sp-1];


		//比較演算
		if(idCalc==CALC_PE){
			if(dbl_stack[sp-2]<=dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_QE){
			if(dbl_stack[sp-2]>=dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_P){
			if(dbl_stack[sp-2]<dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_Q){
			if(dbl_stack[sp-2]>dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_NOTEQUAL){
			if(dbl_stack[sp-2]!=dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_EQUAL){
			if(dbl_stack[sp-2]==dbl_stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}

		//論理演算
		else if(idCalc==CALC_XOR)			dbl_stack[sp-2]=(double)((long)dbl_stack[sp-2]^(long)dbl_stack[sp-1]);
		else if(idCalc==CALC_OR)			dbl_stack[sp-2]=(double)((long)dbl_stack[sp-2]|(long)dbl_stack[sp-1]);
		else if(idCalc==CALC_AND)			dbl_stack[sp-2]=(double)((long)dbl_stack[sp-2]&(long)dbl_stack[sp-1]);

		//シフト演算
		else if(idCalc==CALC_SHL)			dbl_stack[sp-2]=(double)((DWORD)dbl_stack[sp-2]<<(DWORD)dbl_stack[sp-1]);
		else if(idCalc==CALC_SHR)			dbl_stack[sp-2]=(double)((DWORD)dbl_stack[sp-2]>>(DWORD)dbl_stack[sp-1]);

		//算術演算
		else if(idCalc==CALC_ADDITION)		dbl_stack[sp-2]+=dbl_stack[sp-1];
		else if(idCalc==CALC_SUBTRACTION)	dbl_stack[sp-2]-=dbl_stack[sp-1];
		else if(idCalc==CALC_MOD)			dbl_stack[sp-2]=(double)((long)dbl_stack[sp-2]%(long)dbl_stack[sp-1]);
		else if(idCalc==CALC_PRODUCT)		dbl_stack[sp-2]*=dbl_stack[sp-1];
		else if(idCalc==CALC_QUOTIENT){
			if(dbl_stack[sp-1])
				dbl_stack[sp-2]/=dbl_stack[sp-1];
			else{
				//ゼロ割りエラーを検地
				SetError(56,NULL,cp);
			}
		}
		else if(idCalc==CALC_INTQUOTIENT){
			if(dbl_stack[sp-1])
				dbl_stack[sp-2]=(double)(long)(dbl_stack[sp-2]/dbl_stack[sp-1]);
			else{
				//ゼロ割りエラーを検地
				SetError(56,NULL,cp);
			}
		}
		else if(idCalc==CALC_POWER)			dbl_stack[sp-2]=pow(dbl_stack[sp-2],dbl_stack[sp-1]);
	}
	else{
		///////////////
		// 整数演算
		///////////////

		if(IsRealNumberType(type_stack[sp-2])) i64stack[sp-2]=(_int64)dbl_stack[sp-2];
		if(IsRealNumberType(type_stack[sp-1])) i64stack[sp-1]=(_int64)dbl_stack[sp-1];


		//比較演算
		if(idCalc==CALC_PE){
			if(IsSignedType(AnswerType)){
				if(i64stack[sp-2]<=i64stack[sp-1]) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			else{
				if(((unsigned _int64)i64stack[sp-2])<=((unsigned _int64)i64stack[sp-1])) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_QE){
			if(IsSignedType(AnswerType)){
				if(i64stack[sp-2]>=i64stack[sp-1]) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			else{
				if(((unsigned _int64)i64stack[sp-2])>=((unsigned _int64)i64stack[sp-1])) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_P){
			if(IsSignedType(AnswerType)){
				if(i64stack[sp-2]<i64stack[sp-1]) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			else{
				if(((unsigned _int64)i64stack[sp-2])<((unsigned _int64)i64stack[sp-1])) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_Q){
			if(IsSignedType(AnswerType)){
				AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
				if(i64stack[sp-2]>i64stack[sp-1]) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			else{
				if(((unsigned _int64)i64stack[sp-2])>((unsigned _int64)i64stack[sp-1])) i64stack[sp-2]=-1;
				else i64stack[sp-2]=0;
			}
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_NOTEQUAL){
			if(i64stack[sp-2]!=i64stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}
		else if(idCalc==CALC_EQUAL){
			if(i64stack[sp-2]==i64stack[sp-1]) i64stack[sp-2]=-1;
			else i64stack[sp-2]=0;
			AnswerType=DEF_LONG;
		}

		//論理演算
		else if(idCalc==CALC_XOR)			i64stack[sp-2]^=i64stack[sp-1];
		else if(idCalc==CALC_OR)			i64stack[sp-2]|=i64stack[sp-1];
		else if(idCalc==CALC_AND)			i64stack[sp-2]&=i64stack[sp-1];

		//シフト演算
		else if(idCalc==CALC_SHL){
			i64stack[sp-2]<<=(DWORD)i64stack[sp-1];
			if(IsSignedType(AnswerType)) AnswerType=DEF_LONG;
			else AnswerType=DEF_DWORD;
		}
		else if(idCalc==CALC_SHR){
			i64stack[sp-2]>>=(DWORD)i64stack[sp-1];
			if(IsSignedType(AnswerType)) AnswerType=DEF_LONG;
			else AnswerType=DEF_DWORD;
		}

		//算術演算
		else if(idCalc==CALC_ADDITION)		i64stack[sp-2]+=i64stack[sp-1];
		else if(idCalc==CALC_SUBTRACTION)	i64stack[sp-2]-=i64stack[sp-1];
		else if(idCalc==CALC_MOD)			i64stack[sp-2]%=i64stack[sp-1];
		else if(idCalc==CALC_PRODUCT)		i64stack[sp-2]*=i64stack[sp-1];
		else if(idCalc==CALC_QUOTIENT||
			idCalc==CALC_INTQUOTIENT){
			if(i64stack[sp-1])
				i64stack[sp-2]/=i64stack[sp-1];
			else{
				//ゼロ割りエラーを検地
				SetError(56,NULL,cp);
			}
		}
		else if(idCalc==CALC_POWER)			i64stack[sp-2]=(_int64)pow((double)i64stack[sp-2],(double)i64stack[sp-1]);

		if(IsSignedType(AnswerType)){
			if(AnswerType==DEF_CHAR&&(i64stack[sp-2]<CHAR_MIN||CHAR_MAX<i64stack[sp-2])){
				//符号有り8ビット値をはみ出したとき
				AnswerType=DEF_INTEGER;
			}
			if(AnswerType==DEF_INTEGER&&(i64stack[sp-2]<SHRT_MIN||SHRT_MAX<i64stack[sp-2])){
				//符号有り16ビット値をはみ出したとき
				AnswerType=DEF_LONG;
			}
			if(i64stack[sp-2]<LONG_MIN||LONG_MAX<i64stack[sp-2]){
				//符号有り32ビット値をはみ出したとき
				AnswerType=DEF_INT64;
			}
		}
		else{
			if(UINT_MAX<((unsigned _int64)i64stack[sp-2])){
				//符号無し32ビット値をはみ出したとき
				AnswerType=DEF_QWORD;
			}
		}
	}

	type_stack[sp-2]=AnswerType;
	index_stack[sp-2]=-1;

	sp--;
	*pStackPointer=sp;
}

int StaticCalculation(bool enableerror, char *Command,int BaseType,_int64 *pi64data,LONG_PTR *plpIndex,BOOL bDebuggingWatchList){
	extern HANDLE hHeap;
	extern int cp;
	int i,i2,i3,PareNum;
	char Parms[1024],temporary[VN_SIZE],temp2[VN_SIZE];

	_int64 i64data;
	double nums[255];
	_int64 i64nums[255];
	char *StrPtr[255];
	long calc[255];
	_int64 stack[255];
	int type[255];
	LONG_PTR before_index[255];
	int sp,pnum;

	*pi64data=0;
	if(Command[0]=='\0') return 0;

	for(i=0,i2=0,sp=0,pnum=0,PareNum=0;;i++,i2++){
		if(Command[i]=='\"'){
			Parms[i2]=Command[i];
			for(i++,i2++;;i++,i2++){
				Parms[i2]=Command[i];
				if(Command[i]=='\"') break;
			}
			continue;
		}
		else if(Command[i]=='['){
			i3=GetStringInBracket(Parms+i2,Command+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		else if(Command[i]=='('){
			if(i==0){
				PareNum++;
				i2=-1;
				continue;
			}
			else if(IsNumCalcMark_Back(Command,i-1)||Command[i-1]=='('){
				PareNum++;
				i2=-1;
				continue;
			}
			else{
				//配列変数の場合を考慮
				i3=GetStringInPare(Parms+i2,Command+i);
				i+=i3-1;
				i2+=i3-1;
				continue;
			}
		}
		else if(Command[i]==')'){
			PareNum--;
			i2--;
			continue;
		}
		else if(IsNumCalcMark(Command,i)||Command[i]=='\0'){
			if((Command[i]=='+'||Command[i]=='-')&&(Command[i-1]=='e'||Command[i-1]=='E')){
				if(IsExponent(Command,i)){
					Parms[i2]=Command[i];
					continue;
				}
			}
			Parms[i2]=0;

			if(stack[sp-1]==CALC_AS&&Command[i]=='*'){
				for(i3=0;i3<i2;i3++){
					if(Parms[i2]!='*') break;
				}
				if(i3==i2){
					//"*"をポインタ指定文字として認識する
					Parms[i2]=Command[i];
					continue;
				}
			}

			calc[pnum]=0;
			if(i2){
				before_index[pnum]=-1;

				i3=GetCallProcName(Parms,temporary);
				if(Parms[i3]=='('){
					lstrcpy(temp2,Parms+i3+1);
					temp2[lstrlen(temp2)-1]=0;

					if(lstrcmpi(temporary,"SizeOf")==0){
						//SizeOf関数

						type[pnum]=DEF_LONG;

						LONG_PTR lpIndex;
						i3=GetTypeFixed(temp2,&lpIndex);
						if(i3==-1){
							extern int cp;
							if(enableerror) SetError(3,temp2,cp);
							return 0;
						}
						i64nums[pnum]=GetTypeSize(i3,lpIndex);
						StrPtr[pnum]=0;
					}
					else{
						//定数関数

						if(!GetConstCalcBuffer(temporary,temp2,Parms)){
							if(enableerror) SetError(3,temporary,cp);
							return 0;
						}

						type[pnum]=StaticCalculation(true, Parms,BaseType,&i64data,&before_index[pnum]);
						if(IsRealNumberType(type[pnum])){
							//整数型
							memcpy(&nums[pnum],&i64data,sizeof(double));
						}
						else{
							//整数型
							i64nums[pnum]=i64data;
						}

						StrPtr[pnum]=0;
					}
				}
				else{
					if(Parms[0]=='\"'){
						//文字列の場合（比較演算子を考慮）
						RemoveStringQuotes(Parms);
						i2=lstrlen(Parms);

StrLiteral:
						nums[pnum]=i2;
						StrPtr[pnum]=(char *)HeapAlloc(hHeap,0,i2+1);
						memcpy(StrPtr[pnum],Parms,i2);
						StrPtr[pnum][i2]=0;

						type[pnum]=DEF_PTR_BYTE;
						before_index[pnum]=LITERAL_STRING;
					}
					else if((Parms[0]=='e'||Parms[0]=='E')&&
						(Parms[1]=='x'||Parms[1]=='X')&&
						Parms[2]=='\"'){
						//拡張文字列
						RemoveStringQuotes(Parms+2);
						i2=FormatString_EscapeSequence(Parms+2);
						nums[pnum]=i2;
						StrPtr[pnum]=(char *)HeapAlloc(hHeap,0,(int)i2+1);
						memcpy(StrPtr[pnum],Parms+2,i2);
						StrPtr[pnum][i2]=0;

						type[pnum]=DEF_PTR_BYTE;
						before_index[pnum]=LITERAL_STRING;
					}
					else if(IsVariableTopChar(Parms[0])||Parms[0]=='*'){
						if(bDebuggingWatchList){
							//////////////////////////
							// 変数（デバッグ時のみ）
							//////////////////////////

							RELATIVE_VAR RelativeVar;
							LONG_PTR lpIndex;
							int ss[MAX_ARRAYDIM];
							void *offset;
							DWORD dwData;
							SIZE_T stAccBytes;
							float flt;

							extern HANDLE hDebugProcess;

							i3=Debugging_GetVarOffset(Parms,&i2,&RelativeVar,&lpIndex,ss);
							if(i3==0){
								//式エラー
								return 0;
							}
							if(i3==-1){
								//メモリにアクセスできないとき
								return -1;
							}

							if(i3){
								StrPtr[pnum]=0;
								offset=(void *)Debugging_GetVarPtr(&RelativeVar);

								type[pnum]=i2;

								if(i2==DEF_DOUBLE){
									i3=ReadProcessMemory(hDebugProcess,offset,&nums[pnum],sizeof(double),&stAccBytes);
								}
								else if(i2==DEF_SINGLE){
									if(i3=ReadProcessMemory(hDebugProcess,offset,&flt,sizeof(float),&stAccBytes)){
										nums[pnum]=(double)flt;
									}
								}
								else if(IsPtrType(i2)){
									LONG_PTR lpData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&lpData,sizeof(LONG_PTR),&stAccBytes)){
										i64nums[pnum]=(_int64)lpData;
									}
								}
								else if(Is64Type(i2)){
									type[pnum]=DEF_INT64;

									i3=ReadProcessMemory(hDebugProcess,offset,&i64nums[pnum],sizeof(_int64),&stAccBytes);
								}

								else if(i2==DEF_LONG){
									long lData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&lData,sizeof(long),&stAccBytes)){
										i64nums[pnum]=(_int64)lData;
									}
								}
								else if(i2==DEF_DWORD){
									if(i3=ReadProcessMemory(hDebugProcess,offset,&dwData,sizeof(DWORD),&stAccBytes)){
										i64nums[pnum]=(_int64)dwData;
									}
								}
								else if(i2==DEF_INTEGER){
									short shortData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&shortData,sizeof(short),&stAccBytes)){
										i64nums[pnum]=(_int64)shortData;
									}
								}
								else if(i2==DEF_WORD){
									WORD wData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&wData,sizeof(WORD),&stAccBytes)){
										i64nums[pnum]=(_int64)wData;
									}
								}
								else if(i2==DEF_CHAR){
									char charData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&charData,sizeof(char),&stAccBytes)){
										i64nums[pnum]=(_int64)charData;
									}
								}
								else if(i2==DEF_BYTE){
									BYTE byteData;
									if(i3=ReadProcessMemory(hDebugProcess,offset,&byteData,sizeof(BYTE),&stAccBytes)){
										i64nums[pnum]=(_int64)byteData;
									}
								}
								else return 0;

								if(!i3){
									//読み込みに失敗
									return -1;
								}
								goto JumpConst;
							}
						}


						/////////
						//定数
						/////////
						double dbl;
						StrPtr[pnum]=0;
						type[pnum]=GetConstValue(Parms,&dbl,temporary,&before_index[pnum]);
						if(type[pnum]!=-1){
							if(IsRealNumberType(type[pnum])){
								//実数型
								nums[pnum]=dbl;
							}
							else if(Is64Type(type[pnum])){
								//64ビット整数
								memcpy(&i64nums[pnum],&dbl,sizeof(_int64));
							}
							else if(IsWholeNumberType(type[pnum])){
								//整数
								i64nums[pnum]=(_int64)dbl;
							}
							else if(type[pnum]==DEF_STRING){
								//リテラル文字列

								//バイト数
								nums[pnum]=dbl;
								i2=(int)dbl;

								memcpy(Parms,temporary,(int)nums[pnum]);
								goto StrLiteral;
							}
							else{
								//エラー
								if(enableerror) SetError(300,NULL,cp);
								return -1;
							}
							goto JumpConst;
						}


						//////////////
						// 型名の場合
						//////////////

						type[pnum]=GetTypeFixed(Parms,&before_index[pnum]);

						if(type[pnum]==-1){
							if(bDebuggingWatchList) return -1;
							//エラー
							if(enableerror) SetError(33,NULL,cp);
							return 0;
						}
JumpConst:;
					}
					else{
						//リテラル値
						StrPtr[pnum]=0;
						type[pnum]=GetLiteralValue(Parms,&i64data,BaseType);
						if(IsRealNumberType(type[pnum])){
							//実数型
							memcpy(&nums[pnum],&i64data,sizeof(double));
						}
						else{
							//整数型
							i64nums[pnum]=i64data;
							before_index[pnum]=GetLiteralIndex(i64data);
						}
					}
				}

				pnum++;
			}
			else{
				if(!(Command[i]=='+'||Command[i]=='-'||(Command[i]==1&&Command[i+1]==ESC_NOT))){
					if(enableerror) SetError(1,NULL,cp);
					return 0;
				}
				if(Command[i]=='+'){
					i2=-1;
					continue;
				}
			}

			if(Command[i]=='\0'){
				for(;sp>0;pnum++){
					sp--;
					calc[pnum]=(int)stack[sp];
				}
				break;
			}

			//論理演算子
			if(Command[i]==1&&Command[i+1]==ESC_XOR) i3=CALC_XOR;
			else if(Command[i]==1&&Command[i+1]==ESC_OR) i3=CALC_OR;
			else if(Command[i]==1&&Command[i+1]==ESC_AND) i3=CALC_AND;
			else if(Command[i]==1&&Command[i+1]==ESC_NOT) i3=CALC_NOT;

			//ビット演算子（優先順位は算術演算子の後部）
			else if(Command[i]=='<'&&Command[i+1]=='<'){
				i3=CALC_SHL;
				i++;
			}
			else if(Command[i]=='>'&&Command[i+1]=='>'){
				i3=CALC_SHR;
				i++;
			}

			//比較演算子
			else if(Command[i]=='<'&&Command[i+1]=='='||
				Command[i]=='='&&Command[i+1]=='<'){
				i3=CALC_PE;
				i++;
			}
			else if(Command[i]=='>'&&Command[i+1]=='='||
				Command[i]=='='&&Command[i+1]=='>'){
				i3=CALC_QE;
				i++;
			}
			else if(Command[i]=='<'&&Command[i+1]=='>'||
				Command[i]=='>'&&Command[i+1]=='<'){
				i3=CALC_NOTEQUAL;
				i++;
			}
			else if(Command[i]=='=') i3=CALC_EQUAL;
			else if(Command[i]=='<') i3=CALC_P;
			else if(Command[i]=='>') i3=CALC_Q;

			//算術演算子
			else if(Command[i]=='+'||Command[i]=='&') i3=CALC_ADDITION;
			else if(Command[i]=='-'&&i2) i3=CALC_SUBTRACTION;
			else if(Command[i]==1&&Command[i+1]==ESC_MOD) i3=CALC_MOD;
			else if(Command[i]=='*') i3=CALC_PRODUCT;
			else if(Command[i]=='/') i3=CALC_QUOTIENT;
			else if(Command[i]=='\\') i3=CALC_INTQUOTIENT;
			else if(Command[i]=='-'&&i2==0) i3=CALC_MINUSMARK;
			else if(Command[i]=='^') i3=CALC_POWER;
			else if(Command[i]==1&&Command[i+1]==ESC_AS) i3=CALC_AS;

			i3+=PareNum*100;
			if(sp){
				if(stack[sp-1]>i3-3&&
					(!(
					(stack[sp-1]%100==CALC_MINUSMARK||stack[sp-1]%100==CALC_NOT)&&
					(i3%100==CALC_MINUSMARK||i3%100==CALC_NOT)
					))
					){
					for(;sp>0;){
						sp--;
						calc[pnum]=(int)stack[sp];
						pnum++;
						if(!(stack[sp-1]>i3-3)) break;
					}
				}
			}
			stack[sp]=i3;
			sp++;

			if(Command[i]==1) i++;
			i2=-1;
			continue;
		}
		Parms[i2]=Command[i];
	}

	int type_stack[255];
	LONG_PTR index_stack[255];
	int idCalc;
	for(i=0,sp=0;i<pnum;i++){

		//型チェック（正常でない場合はエラーにする）
		TypeErrorCheck(stack,sp,calc[i]%100);

		idCalc=calc[i]%100;

		switch(idCalc){
			//数値
			case 0:
				dbl_stack[sp]=nums[i];
				i64stack[sp]=i64nums[i];
				type_stack[sp]=type[i];
				index_stack[sp]=before_index[i];

				stack[sp]=(_int64)StrPtr[i];
				sp++;
				break;

			//論理演算
			case CALC_NOT:
				if(IsRealNumberType(type_stack[sp-1])){
					//実数演算
					dbl_stack[sp-1]=(double)(~(long)dbl_stack[sp-1]);
				}
				else{
					//整数演算
					i64stack[sp-1]=~i64stack[sp-1];
				}
				break;

			//比較演算
			case CALC_PE:
			case CALC_QE:
			case CALC_P:
			case CALC_Q:
			case CALC_NOTEQUAL:
			case CALC_EQUAL:

			//論理演算
			case CALC_XOR:
			case CALC_OR:
			case CALC_AND:

			//シフト演算
			case CALC_SHL:
			case CALC_SHR:

			//算術演算
			case CALC_ADDITION:
			case CALC_SUBTRACTION:
			case CALC_MOD:
			case CALC_PRODUCT:
			case CALC_QUOTIENT:
			case CALC_INTQUOTIENT:
			case CALC_POWER:
				StaticTwoTerm(idCalc,type_stack,index_stack,&sp,BaseType);
				break;

			case CALC_MINUSMARK:
				if(IsRealNumberType(type_stack[sp-1])){
					//実数演算
					dbl_stack[sp-1]=-dbl_stack[sp-1];
				}
				else{
					//整数演算
					i64stack[sp-1]=-i64stack[sp-1];
				}
				break;
			case CALC_AS:
				if(IsWholeNumberType(type_stack[sp-2])){
					if(IsRealNumberType(type_stack[sp-1])){
						dbl_stack[sp-2]=(double)i64stack[sp-2];
					}
				}
				if(IsRealNumberType(type_stack[sp-2])){
					if(IsWholeNumberType(type_stack[sp-1])){
						i64stack[sp-2]=(_int64)dbl_stack[sp-2];
					}
				}
				type_stack[sp-2]=type_stack[sp-1];
				index_stack[sp-2]=index_stack[sp-1];
				sp--;
				break;
		}
	}
	if(stack[0]){
		//文字列ポインタ
		*pi64data=(_int64)stack[0];
		*plpIndex=index_stack[0];
		return type_stack[0];
	}

	if(IsRealNumberType(type_stack[0])){
		//実数
		memcpy(pi64data,&dbl_stack[0],sizeof(double));
		return type_stack[0];
	}

	//整数
	*pi64data=i64stack[0];

	if(plpIndex){
		*plpIndex=index_stack[0];
		if(*plpIndex==-1){
			if(Is64Type(type_stack[0])==0&&IsRealNumberType(type_stack[0])==0){
				//整数（符号有り/無し）
				i64data=*pi64data;

				*plpIndex=GetLiteralIndex(i64data);
			}
		}
	}

	return type_stack[0];
}

#pragma optimize("", off)
DWORD GetLiteralValue(char *value,_int64 *pi64,int BaseType){
	extern HANDLE hHeap;
	extern int cp;
	int i,i2,i3,sw1,sw2,bDbl;
	double dbl;
	char temporary[255];

	if(value[0]=='&'){
		_int64 i64temp;
		lstrcpy(temporary,value);

		if(temporary[1]=='o'||temporary[1]=='O'){
			for(i=2;;i++){
				i3=temporary[i]-0x30;
				if(i3<0||7<i3) break;
				temporary[i]=i3;
			}
			if(temporary[i]){
				SetError(57,NULL,cp);
				return DEF_BYTE;
			}

			i64temp=1;
			*pi64=0;
			for(i--;i>=2;i--){
				*pi64=(*pi64)+(_int64)(i64temp*temporary[i]);
				i64temp*=8;
			}
		}
		else if(temporary[1]=='h'||temporary[1]=='H'){
			CharUpper(temporary+2);
			for(i=2;;i++){
				i3=temporary[i]-0x30;
				if(i3<0||9<i3){
					i3=temporary[i]-0x41+10;
					if(i3<0xA||0xF<i3) break;
				}
				temporary[i]=i3;
			}
			if(temporary[i]){
				SetError(58,NULL,cp);
				return DEF_BYTE;
			}

			i64temp=1;
			*pi64=0;
			for(i--;i>=2;i--){
				*pi64=(*pi64)+(_int64)(i64temp*temporary[i]);
				i64temp*=0x10;
			}
		}
		else{
			SetError(12,"&",cp);
			return DEF_BYTE;
		}

		if(BaseType==DEF_INT64||BaseType==DEF_QWORD) return DEF_QWORD;

		if(((unsigned _int64)*pi64)<=UCHAR_MAX){
			//符号無し8ビット整数のリテラル値
			return DEF_BYTE;
		}
		else if(((unsigned _int64)*pi64)<=USHRT_MAX){
			//符号無し16ビット整数のリテラル値
			return DEF_WORD;
		}
		else if(((unsigned _int64)*pi64)<=UINT_MAX){
			//符号無し32ビット整数のリテラル値
			return DEF_DWORD;
		}
		else{
			//符号無し64ビット整数のリテラル値
			return DEF_QWORD;
		}
	}
	else if((value[0]>='0'&&value[0]<='9')||value[0]=='+'||value[0]=='-'||(value[0]=='.'&&(!IsVariableTopChar(value[1])))){
		for(i=0;;i++){
			if(value[i]!='-') break;
		}
		if(value[i]=='.'){
			SlideString(value+i,1);
			value[i]='0';
		}

		//エラーチェック
		bDbl=0;
		sw1=0;
		sw2=0;
		for(i2=i;;i2++){
			if(value[i2]=='\0') break;
			if(value[i2]=='.') bDbl=1;
			if(!((value[i2]>='0'&&value[i2]<='9')||value[i2]=='.')){
				if((value[i2]=='e'||value[i2]=='E')&&sw1==0){
					bDbl=1;
					sw1=1;
				}
				else if((value[i2]=='+'||value[i2]=='-')&&sw1==1&&sw2==0) sw2=1;
				else{
					extern BOOL bDebugRun;
					if(bDebugRun) return DEF_DOUBLE;

					SetError(3,value,cp);
					return DEF_DOUBLE;
				}
			}
		}

		if(bDbl){
			//実数のリテラル値
			if(i%2) dbl=-atof(value+i);
			else dbl=atof(value+i);

			memcpy(pi64,&dbl,sizeof(double));

			if(BaseType==DEF_SINGLE) return DEF_SINGLE;

			return DEF_DOUBLE;
		}
		else{
			*pi64=_atoi64(value+i);
			if(i%2) *pi64=-(*pi64);

			if(BaseType==DEF_INT64||BaseType==DEF_QWORD) return BaseType;

			if(LONG_MIN<=*pi64&&*pi64<=LONG_MAX){
				//符号有り32ビット整数のリテラル値
				return DEF_LONG;
			}
			else if(*pi64<=UINT_MAX){
				//符号無し32ビット整数のリテラル値
				return DEF_DWORD;
			}
			else{
				//符号有り64ビット整数のリテラル値
				return DEF_INT64;
			}
		}
	}

	extern BOOL bDebugRun;
	if(bDebugRun) return DEF_DOUBLE;

	SetError(33,NULL,cp);
	return DEF_DOUBLE;
}
#pragma optimize("", on)

BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer){
	extern HANDLE hHeap;
	int i2,i3,i4,num;
	char temporary[VN_SIZE];
	char *pParms[MAX_PARMS];

	CONSTINFO *pci;
	pci=GetConstHash(name);
	if(!pci) return 0;

	num=0;
	i2=0;
	while(1){
		i2=GetOneParameter(Parameter,i2,temporary);

		pParms[num]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
		lstrcpy(pParms[num],temporary);

		num++;
		if(Parameter[i2]=='\0') break;
	}
	if(num!=pci->ParmNum){
		extern int cp;
		for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
		SetError(10,name,cp);
		lstrcpy(pCalcBuffer,"0");
		return 1;
	}

	i2=0;
	i4=0;
	while(1){

		//数式内の項を取得
		for(i3=0;;i2++,i3++){
			if(!IsVariableChar(pci->StrValue[i2])){
				temporary[i3]=0;
				break;
			}
			temporary[i3]=pci->StrValue[i2];
		}

		//パラメータと照合する
		for(i3=0;i3<pci->ParmNum;i3++){
			if(lstrcmp(pci->ppParm[i3],temporary)==0) break;
		}

		if(i3==pci->ParmNum){
			//パラメータでないとき
			lstrcpy(pCalcBuffer+i4,temporary);
			i4+=lstrlen(temporary);
		}
		else{
			//パラメータのとき
			lstrcpy(pCalcBuffer+i4,pParms[i3]);
			i4+=lstrlen(pParms[i3]);
		}

		//演算子をコピー
		for(;;i2++,i4++){
			if(pci->StrValue[i2]==1){
				pCalcBuffer[i4++]=pci->StrValue[i2++];
				pCalcBuffer[i4]=pci->StrValue[i2];
				continue;
			}
			if(IsVariableTopChar(pci->StrValue[i2])) break;
			pCalcBuffer[i4]=pci->StrValue[i2];
			if(pci->StrValue[i2]=='\0') break;
		}

		if(pci->StrValue[i2]=='\0') break;
	}

	for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);

	return 1;
}
DWORD GetConstValue(char *name,double *pDbl,char *buffer,LONG_PTR *plpIndex){
	CONSTINFO *pci;
	pci=GetConstHash(name);
	if(pci){
		//定数が見つかったとき

		if(pci->StrValue){
			//文字列定数

			//バイト数
			*pDbl=pci->DblValue;

			//データ
			memcpy(buffer,pci->StrValue,(int)pci->DblValue);

			if(plpIndex) *plpIndex=pci->lpIndex;

			return DEF_STRING;
		}
		else{
			if(pci->type==DEF_INT64){
				memcpy(pDbl,&pci->i64Value,sizeof(_int64));
				return DEF_INT64;
			}

			if(plpIndex) *plpIndex=pci->lpIndex;

			*pDbl=pci->DblValue;
			return pci->type;
		}
	}

	if(plpIndex) *plpIndex=-1;

	return -1;
}
BOOL IsStringObjectType(TYPEINFO *pTypeInfo){
	if(pTypeInfo->type==DEF_OBJECT){
		if(lstrcmp(pTypeInfo->u.pobj_Class->name,"String")==0){
			return 1;
		}
	}
	return 0;
}
BOOL IsStringSubsituation(CClass *pobj_c){
	//String受け入れ可能な "=" 演算子をオーバーロードしているかどうかを調べる
	BOOL bRet=0;

	SUBINFO **ppsi;
	int num;
	ppsi=pobj_c->GetOperatorSubInfo(CALC_SUBSITUATION,num);
	if(num==0){
		bRet=0;
		goto finish;
	}

	int i;
	for(i=0;i<num;i++){
		if(ppsi[i]->ParmNum==2){
			TYPEINFO TypeInfo={ppsi[i]->pParmInfo[1].type,ppsi[i]->pParmInfo[1].u.index};
			if(IsStringObjectType(&TypeInfo)){
				bRet=1;
				goto finish;
			}
		}
	}

finish:
	HeapDefaultFree(ppsi);
	return bRet;
}
int IsStrCalculation(char *Command){
	int i,i2,i3,i4,type,PareNum;
	double dbl;
	char temporary[VN_SIZE],temp2[8192];

	for(i=0,i2=0;;i++){
		if(Command[i]=='('){
			for(i++,PareNum=1;;i++){
				if(Command[i]=='(') PareNum++;
				else if(Command[i]==')'){
					PareNum--;
					if(PareNum==0) break;
				}
			}
			continue;
		}
		if(Command[i]=='['){
			for(i++,PareNum=1;;i++){
				if(Command[i]=='[') PareNum++;
				else if(Command[i]==']'){
					PareNum--;
					if(PareNum==0) break;
				}
			}
			continue;
		}
		if(Command[i]=='\"'){
			i++;
			while(Command[i]!='\"') i++;
			continue;
		}
		if(Command[i]=='\0'){
			if(IsVariableTopChar(Command[i2])||
				Command[i2]=='.'&&IsVariableTopChar(Command[i2+1])){

				if((Command[i2]=='e'||Command[i2]=='E')&&
					(Command[i2+1]=='x'||Command[i2+1]=='X')&&
					Command[i2+2]=='\"'){
					//拡張文字列
					return 1;
				}

				for(i3=0;;i3++){
					if(Command[i2+i3]=='('){
						temporary[i3]=0;
						break;
					}
					temporary[i3]=Command[i2+i3];
					if(Command[i2+i3]=='\0') break;
				}
				if(Command[i2+i3]=='('){
					TYPEINFO TypeInfo;

					//DLL関数の場合
					DECLAREINFO *pdi;
					pdi=GetDeclareHash(temporary);
					if(pdi){
						TypeInfo.type=pdi->ReturnType;
						TypeInfo.u.lpIndex=pdi->u.ReturnIndex;
						if(IsStringObjectType(&TypeInfo)) return 1;
						return 0;
					}

					//ユーザー定義関数
					SUBINFO *psi;
					psi=GetSubHash(temporary);
					if(psi){
						TypeInfo.type=psi->ReturnType;
						TypeInfo.u.lpIndex=psi->u.ReturnIndex;
						if(IsStringObjectType(&TypeInfo)) return 1;
						return 0;
					}

					//組み込み関数
					i4=GetFunctionFromName(temporary);
					if(i4){
						//組み込み関数は文字列を返さない
						return 0;
					}

					//定数
					CONSTINFO *pci;
					pci=GetConstHash(temporary);
					if(pci){

						if(pci->ParmNum){
							//マクロ関数の場合
							GetStringInPare_RemovePare(temporary,Command+i2+i3+1);
							GetConstCalcBuffer(pci->name,temporary,temp2);
							return IsStrCalculation(temp2);
						}

						if(pci->type==DEF_STRING) return 1;
						else return 0;
					}
				}

				//定数
				i3=GetConstValue(Command+i2,&dbl,temporary,0);
				if(i3==DEF_STRING) return 1;	//文字列
				if(i3!=-1) return 0;			//数値

				//変数
				RELATIVE_VAR RelativeVar;
				CClass *pobj_Class;
				if(!GetVarOffset(1,Command+i2,&type,&RelativeVar,(LONG_PTR *)&pobj_Class)){
					//エラー
					return -1;
				}
				if(type==DEF_OBJECT){
					if(lstrcmp(pobj_Class->name,"String")==0){
						return 1;
					}
					return 0;
				}
			}
			else if(Command[i2]=='\"') return 1;
			break;
		}
		if(IsNumCalcMark(Command,i)||IsStrCalcMark(Command[i])){
			if(IsStrCalcMark(Command[i])){

				//&H、&O表記の場合を考慮
				if(i==0) continue;
				if(IsNumCalcMark(Command,i-1)) continue;

				if(Command[i+1]=='(') break;
				i2=i+1;
				continue;
			}
			break;
		}
	}
	return 0;
}

BYTE GetCalcId(char *Command,int *pi){
	*pi=0;

	if(Command[0]==1) *pi=1;

	//論理演算子
	if(Command[0]==1&&Command[1]==ESC_XOR) return CALC_XOR;
	else if(Command[0]==1&&Command[1]==ESC_OR) return CALC_OR;
	else if(Command[0]==1&&Command[1]==ESC_AND) return CALC_AND;
	else if(Command[0]==1&&Command[1]==ESC_NOT) return CALC_NOT;

	//ビット演算子（優先順位は算術演算子の後部）
	else if(Command[0]=='<'&&Command[1]=='<'){
		*pi=1;
		return CALC_SHL;
	}
	else if(Command[0]=='>'&&Command[1]=='>'){
		*pi=1;
		return CALC_SHR;
	}

	//比較演算子
	else if(Command[0]=='<'&&Command[1]=='='||
		Command[0]=='='&&Command[1]=='<'){
		*pi=1;
		return CALC_PE;
	}
	else if(Command[0]=='>'&&Command[1]=='='||
		Command[0]=='='&&Command[1]=='>'){
		*pi=1;
		return CALC_QE;
	}
	else if(Command[0]=='<'&&Command[1]=='>'||
		Command[0]=='>'&&Command[1]=='<'){
		*pi=1;
		return CALC_NOTEQUAL;
	}
	else if(Command[0]=='=') return CALC_EQUAL;
	else if(Command[0]=='<') return CALC_P;
	else if(Command[0]=='>') return CALC_Q;

	//算術演算子
	else if(Command[0]=='+') return CALC_ADDITION;
	else if(Command[0]=='-') return CALC_SUBTRACTION;
	else if(Command[0]=='&') return CALC_STRPLUS;
	else if(Command[0]==1&&Command[1]==ESC_MOD) return CALC_MOD;
	else if(Command[0]=='*') return CALC_PRODUCT;
	else if(Command[0]=='/') return CALC_QUOTIENT;
	else if(Command[0]=='\\') return CALC_INTQUOTIENT;
	else if(Command[0]=='^') return CALC_POWER;
	else if(Command[0]==1&&Command[1]==ESC_AS) return CALC_AS;

	return 0;
}
BOOL GetNumOpeElements(char *Command,int *pnum,
					   char *values[255],long calc[255],long stack[255]){
	extern int cp;
	extern HANDLE hHeap;
	int i,i2,i3,i4,PareNum,sp;
	char temporary[1024];

	for(i=0,i2=0,sp=0,*pnum=0,PareNum=0;;i++,i2++){
		if(Command[i]=='\"'){
			temporary[i2]=Command[i];
			for(i++,i2++;;i++,i2++){
				temporary[i2]=Command[i];
				if(Command[i]=='\"') break;
			}
			continue;
		}
		else if(Command[i]=='['){
			i3=GetStringInBracket(temporary+i2,Command+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		else if(Command[i]=='('){
			if(i==0){
				PareNum++;
				i2=-1;
				continue;
			}
			else if(IsNumCalcMark_Back(Command,i-1)||Command[i-1]=='('){
				PareNum++;
				i2=-1;
				continue;
			}
			else{
				//配列変数の場合を考慮
				i3=GetStringInPare(temporary+i2,Command+i);
				i+=i3-1;
				i2+=i3-1;
				continue;
			}
		}
		else if(Command[i]==')'){
			PareNum--;
			i2--;
			continue;
		}
		else if(IsNumCalcMark(Command,i)||(Command[i]=='&'&&i2!=0)){
			if((Command[i]=='+'||Command[i]=='-')&&(Command[i-1]=='e'||Command[i-1]=='E')){
				if(IsExponent(Command,i)){
					temporary[i2]=Command[i];
					continue;
				}
			}
			temporary[i2]=0;

			if((stack[sp-1]%100)==CALC_AS&&Command[i]=='*'){
				for(i3=0;i3<i2;i3++){
					if(temporary[i2]!='*') break;
				}
				if(i3==i2){
					//"*"をポインタ指定文字として認識する
					temporary[i2]=Command[i];
					continue;
				}
			}

			calc[*pnum]=0;
			if(i2){
				values[*pnum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+255);
				lstrcpy(values[*pnum],temporary);
				(*pnum)++;
			}
			else{
				if(!(Command[i]=='+'||Command[i]=='-'||(Command[i]==1&&Command[i+1]==ESC_NOT))){
					SetError(1,NULL,cp);
					return 0;
				}
				if(Command[i]=='+'){
					i2=-1;
					continue;
				}
			}

			if(Command[i]=='-'&&i2==0){
				i3=CALC_MINUSMARK;
			}
			else{
				i3=GetCalcId(Command+i,&i4);
				i+=i4;
				if(!i3){
					SetError(1,NULL,cp);
					return 0;
				}
			}

			i3+=PareNum*100;
			if(sp){
				if(stack[sp-1]>i3-3&&
					(!(
					(stack[sp-1]%100==CALC_MINUSMARK || stack[sp-1]%100==CALC_NOT || stack[sp-1]%100==CALC_POWER)&&
					(i3%100==CALC_MINUSMARK || i3%100==CALC_NOT)
					))
					){
					for(;sp>0;){
						sp--;
						calc[*pnum]=stack[sp];
						values[*pnum]=0;
						(*pnum)++;
						if(!(stack[sp-1]>i3-3)) break;
					}
				}
			}
			stack[sp]=i3;
			sp++;

			i2=-1;
			continue;
		}
		temporary[i2]=Command[i];
		if(Command[i]=='\0'){
			calc[*pnum]=0;

			values[*pnum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+255);
			lstrcpy(values[*pnum],temporary);
			(*pnum)++;

			for(;sp>0;(*pnum)++){
				sp--;
				calc[*pnum]=stack[sp];
				values[*pnum]=0;
			}
			break;
		}
	}

	return 1;
}