#include "stdafx.h"

#include <Compiler.h>

#include "common.h"

using namespace ActiveBasic::Compiler;

int MakeWholeType(int size,int bSigned){
	switch(size){
		case 1:
			if(bSigned) return DEF_SBYTE;
			else return DEF_BYTE;
			break;
		case 2:
			if(bSigned) return DEF_INTEGER;
			else return DEF_WORD;
			break;
		case 4:
			if(bSigned) return DEF_LONG;
			else return DEF_DWORD;
			break;
		case 8:
			if(bSigned) return DEF_INT64;
			else return DEF_QWORD;
			break;
	}
	return 0;
}

int AutoBigCast(int BaseType,int CalcType){
	int type;
	type=CalcType;

	if(BaseType==0||BaseType==-1){
		//ベースタイプが未定のとき
		return type;
	}

	if(!IsWholeNumberType(type)){
		//整数型ではないときは暗黙の変換は必要なし
		return type;
	}

	if(BaseType==DEF_OBJECT||BaseType==DEF_STRUCT){
		//ベースタイプがオブジェクトのときは暗黙の変換は必要なし
		return type;
	}

	int BaseTypeSize;
	BaseTypeSize=Type(BaseType,-1).GetSize();

	if(IsRealNumberType(BaseType)){
		if(Type(CalcType,-1).GetSize()<4)
			type=MakeWholeType(4,IsSignedType(CalcType));
	}
	else if(BaseTypeSize>Type(CalcType,-1).GetSize()){
		//要求される型のほうがサイズが大きいとき
		type=MakeWholeType(BaseTypeSize,IsSignedType(CalcType));
	}

	if(!type){
		extern int cp;
		compiler.errorMessenger.Output(300,NULL,cp);
	}

	return type;
}

BOOL CheckCalcType(int idCalc,int *type,int sp){
	//演算子の右辺、左辺の型をチェック
	extern int cp;

	//演算子名を取得
	char temporary[255];
	GetCalcName(idCalc,temporary);

	switch(idCalc){

		/////////////////////////////////////
		// 実数に対する論理演算はエラー
		/////////////////////////////////////

		case CALC_XOR:
		case CALC_OR:
		case CALC_AND:
			if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
				//いずれかの項が実数のとき
				compiler.errorMessenger.Output(45,temporary,cp);
				return 0;
			}

			//As以外の演算子に型名が指定されていないかをチェック
			if((type[sp-2]&FLAG_CAST)||(type[sp-1]&FLAG_CAST)){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;

		case CALC_NOT:
			if(IsRealNumberType(type[sp-1])){
				//実数のとき
				compiler.errorMessenger.Output(45,temporary,cp);
				return 0;
			}

			//As以外の演算子に型名が指定されていないかをチェック
			if(type[sp-1]&FLAG_CAST){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;



		/////////////////////////////////////
		// 比較演算はチェック項目なし
		/////////////////////////////////////

		case CALC_PE:
		case CALC_QE:
		case CALC_NOTEQUAL:
		case CALC_EQUAL:
		case CALC_P:
		case CALC_Q:
			//As以外の演算子に型名が指定されていないかをチェック
			if((type[sp-2]&FLAG_CAST)||(type[sp-1]&FLAG_CAST)){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;



		/////////////////////////////////////
		// 算術演算をチェック
		/////////////////////////////////////

		case CALC_ADDITION:
		case CALC_SUBTRACTION:
		case CALC_PRODUCT:
		case CALC_QUOTIENT:
		case CALC_POWER:
			//As以外の演算子に型名が指定されていないかをチェック
			if((type[sp-2]&FLAG_CAST)||(type[sp-1]&FLAG_CAST)){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;

		case CALC_SHL:
		case CALC_SHR:
		case CALC_MOD:
		case CALC_INTQUOTIENT:
			if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
				//いずれかの項が実数のとき
				compiler.errorMessenger.Output(45,temporary,cp);
				return 0;
			}

			//As以外の演算子に型名が指定されていないかをチェック
			if((type[sp-2]&FLAG_CAST)||(type[sp-1]&FLAG_CAST)){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;

		case CALC_AS:
			if((type[sp-1]&FLAG_CAST)==0){
				//型名が指定されていないときはエラー
				compiler.errorMessenger.Output(47,NULL,cp);
				return 0;
			}
			break;

		case CALC_BYVAL:
			if(type[sp-1]&FLAG_CAST){
				//型名が指定されていないときはエラー
				compiler.errorMessenger.Output(47,NULL,cp);
				return 0;
			}
			break;

		case CALC_MINUSMARK:
			//As以外の演算子に型名が指定されていないかをチェック
			if(type[sp-1]&FLAG_CAST){
				compiler.errorMessenger.Output(48,temporary,cp);
				return 0;
			}
			break;
	}
	return 1;
}

int GetReturnType_OperatorProc(int idCalc,const Type &baseType,int *type_stack,LONG_PTR *index_stack,int &sp)
{
	if( sp < 2 )
	{
		Jenga::Throw( "GetReturnType_OperatorProcのspが2以下" );
	}

	Type leftType( type_stack[sp-2], index_stack[sp-2] );
	Type rightType( type_stack[sp-1] & (~FLAG_CAST), index_stack[sp-1] );

	//オーバーロードされたオペレータ関数を呼び出す
	const CClass *pobj_c = &leftType.GetClass();

	std::vector<const UserProc *> subs;
	pobj_c->GetDynamicMethods().Enum( idCalc, subs );
	if( subs.size() == 0 ){
		return 0;
	}


	//項の数
	BOOL bTwoTerm=1;
	if(idCalc==CALC_AS) bTwoTerm=0;



	/////////////////////////////////////////////
	// オーバーロード解決用のパラメータを設定
	/////////////////////////////////////////////


	//_System_LocalThis
	Parameters params;

	if(bTwoTerm){
		params.push_back( new Parameter( "", rightType ) );
	}


	//オーバーロードを解決
	char temporary[255];
	if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
	else GetCalcName(idCalc,temporary);
	const UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType, leftType );

	if(bTwoTerm){
		delete params[0];
	}

	if(!pUserProc){
		return 0;
	}
	else{
		//オーバーロードされていないが、パラメータ個数が一致しないとき
		if(params.size()!=pUserProc->Params().size()){
			return 0;
		}
	}

	sp--;
	type_stack[sp-1]=pUserProc->ReturnType().GetBasicType();
	index_stack[sp-1]=pUserProc->ReturnType().GetIndex();

	return 1;
}

bool Operator_New_GetType(const char *Parameter,const Type &baseType, Type &resultType ){
	char TypeName[VN_SIZE],objectSizeStr[VN_SIZE];
	int i,i2;

	i=0;

	if(Parameter[0]=='['){
		i=GetStringInBracket(objectSizeStr,Parameter);

		SlideString(objectSizeStr+1,-1);
		objectSizeStr[i-2]=0;
	}
	else objectSizeStr[0]=0;

	for(i2=0;;i++,i2++){
		if(Parameter[i]=='(' || Parameter[i]=='['){
			TypeName[i2]=0;
			break;
		}
		TypeName[i2]=Parameter[i];
		if(Parameter[i]=='\0'){
			break;
		}
	}

	if( !compiler.StringToType( TypeName, resultType ) )
	{
		compiler.errorMessenger.Output(3,TypeName,cp);
		return false;
	}

	if( !resultType.IsObject() )
	{
		compiler.errorMessenger.Output(121,NULL,cp);
		return false;
	}

	if( baseType.IsObject() ){
		resultType.SetBasicType( DEF_OBJECT );
	}
	else{
		resultType.SetBasicType( DEF_PTR_OBJECT );
	}
	return true;
}

bool GetMemberTermType( const Type &leftType, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member, bool *pIsVariable )
{
	////////////////////////////////
	// インデクサ（getアクセサ）
	////////////////////////////////

	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	GetArrayElement(member,VarName,ArrayElements);
	if(ArrayElements[0]){
		Type classType;
		if( VarName[0] == '\0' )
		{
			classType = leftType;

			if( classType.IsObject() )
			{
				// 既にuseRegにオブジェクトポインタが格納されており、それに対するインデクサを呼び出す場合
				// ※「プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す」場合にここにくる
			}
		}
		else
		{
			GetMemberType( leftType, VarName, classType, 0, false );
		}

		if( classType.IsObject() )
		{
			if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
				compiler.errorMessenger.Output(1,NULL,cp);
				return false;
			}

			return true;
		}
	}


	///////////////////////////////////////////////////////////////////
	// メンバを検索
	///////////////////////////////////////////////////////////////////
	if( GetMemberType( leftType, member, resultType, 0, false ) ){
		// メンバが見つかったとき

		if( pIsVariable )
		{
			*pIsVariable = true;
		}

		return true;
	}


	///////////////////////////////////////////////////////////////////
	// 動的メソッドを検索
	///////////////////////////////////////////////////////////////////
	char methodName[VN_SIZE] ,lpPtrOffset[VN_SIZE], dummy[1];
	char parameter[VN_SIZE];
	ReferenceKind refType;
	PareOrBracket pareOrBracket = None;
	lstrcpy( methodName, member );
	GetVarFormatString( methodName, parameter, lpPtrOffset, dummy, refType, &pareOrBracket );

	std::vector<const UserProc *> userProcs;
	leftType.GetClass().EnumDynamicMethodsOrInterfaceMethods( methodName, userProcs );
	if(userProcs.size()){
		//オーバーロードを解決
		const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);

		if( pUserProc )
		{
			if(
				pUserProc->Params().size() == 0				// 仮引数の個数は0
				&& parameter[0]								// 実引数は1つ以上
				&& pUserProc->ReturnType().IsObject()		// 戻り値がクラス型の場合
				&& pareOrBracket == Bracket )				// 実引数は[]で囲まれている
			{
				// プロパティ値として返ってきたオブジェクトインスタンスのインデクサを呼び出す

				// まずはプロパティ値を取得
				bool dummyIsVariable;
				GetMemberTermType( leftType, baseType, resultType, termFull, termLeft, methodName, &dummyIsVariable );

				// 戻り値のオブジェクトインスタンスのインデクサを呼び出す
				char temporary[VN_SIZE], temp2[VN_SIZE];
				sprintf( temporary, "[%s]", parameter );
				sprintf( temp2, "%s.%s", termLeft, methodName );
				Type classType = resultType;
				return GetMemberTermType( classType, baseType, resultType, termFull, temp2, temporary, pIsVariable );
			}

			resultType = pUserProc->ReturnType();

			// 型パラメータを解決
			ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );

			return true;
		}
	}

	return false;
}

bool GetTermType( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, bool *pIsClassName, bool *pIsVariable )
{
	char parameter[VN_SIZE];

	// Withを解決
	char termFull[VN_SIZE];
	if(term[0]=='.'){
		GetWithName(termFull);
		lstrcat(termFull,term);
	}
	else lstrcpy(termFull,term);

	char termLeft[VN_SIZE];
	lstrcpy(termLeft,termFull);

	// パース
	char member[VN_SIZE];
	ReferenceKind refType;
	if( SplitMemberName( termFull, termLeft, member, refType ) ){
		///////////////////////////////////////////////////////////////////
		// オブジェクトとメンバに分解できるとき
		// termLeft.member
		///////////////////////////////////////////////////////////////////

		isLiteral = false;

		// オブジェクト側の型を取得
		bool isClassName = false;
		Type leftType;
		if( GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
			if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
				// 左側のオブジェクト部分がBlittable型のとき

				char temporary[VN_SIZE];
				lstrcpy( temporary, termLeft );
				sprintf( termLeft, "%s(%s)",
					compiler.GetObjectModule().meta.GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
					temporary );

				if( !GetTermType( termLeft, Type(), leftType, isLiteral, &isClassName ) ){
					goto globalArea;
				}
			}
		}
		else{
			goto globalArea;
		}

		if( isClassName ){
			// 静的メンバ/メソッドの場合
			goto globalArea;
		}

		if( !leftType.HasMember() ){
			// メンバを持たない型の場合
			return false;
		}

		return GetMemberTermType( leftType, baseType, resultType, termFull, termLeft, member, pIsVariable );
	}


	//////////////////////////////////////////////
	// クラス名かどうかをチェック（静的メンバ用）
	//////////////////////////////////////////////

	if( pIsClassName )
	{
		if( compiler.GetObjectModule().meta.FindClassSupportedTypeDef( LexicalAnalyzer::FullNameToSymbol( termFull ) ) )
		{
			*pIsClassName = true;
			return true;
		}
	}


	/////////////////////////////////////////////////////////////////
	// グローバル属性
	/////////////////////////////////////////////////////////////////
globalArea:


	if(lstrcmpi(termFull,"This")==0)
	{
		if( !compiler.IsCompilingClass() )
		{
			return false;
		}

		//Thisオブジェクト
		resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
		isLiteral = false;
		return true;
	}


	//////////////////////////////////////
	// 関数（DLL、ユーザー定義、組み込み）
	//////////////////////////////////////
	char procName[VN_SIZE];
	char temporary[8192];

	int i2=GetCallProcName(termFull,procName);
	if(termFull[i2]=='('){
		int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);

		void *pProc;
		int idProc=GetProc(procName,(void **)&pProc);

		if(idProc){
			//閉じカッコ")"に続く文字がNULLでないとき
			if(termFull[i2+1+i4+1]!='\0'){
				compiler.errorMessenger.Output(42,NULL,cp);
			}


			////////////////
			// 呼び出し
			////////////////

			if( !CallProc(idProc,pProc,procName,parameter, baseType, resultType, false ) ){
				return false;
			}
			if( resultType.IsNull() ){
				//戻り値が存在しないとき
				return false;
			}

			isLiteral = false;

			return true;
		}
		else
		{
			ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find(
				ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( procName )
			);
			if( pConstMacro )
			{
				if( ActiveBasic::Compiler::LexicalAnalyzer::ConstMacroToExpression( *pConstMacro, parameter, temporary ) )
				{
					/////////////////////////
					// マクロ関数
					/////////////////////////

					//閉じカッコ")"に続く文字がNULLでないときはエラーにする
					if(termFull[i2+1+i4+1]!='\0') compiler.errorMessenger.Output(42,NULL,cp);

					//マクロ関数の場合
					if( !NumOpe_GetType(temporary,Type(),resultType) ){
						return false;
					}

					if( !IS_LITERAL( resultType.GetIndex() ) ){
						//リテラル値ではなかったとき
						isLiteral = false;
					}

					return true;
				}
			}
		}
	}


	////////////////////////////////
	// インデクサ（getアクセサ）
	////////////////////////////////

	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	GetArrayElement(termFull,VarName,ArrayElements);
	if(ArrayElements[0]){
		Type classType;
		GetVarType(VarName,classType,false);
		if( classType.IsObject() ){
			if( !GetReturnTypeOfIndexerGetterProc( classType, resultType ) ){
				compiler.errorMessenger.Output(1,NULL,cp);
				return false;
			}

			isLiteral = false;

			return true;
		}
	}


	////////////////////////////////
	// 変数
	////////////////////////////////

	if( GetVarType( termFull, resultType, false ) ){
		if( resultType.GetBasicType() & FLAG_PTR ){
			//配列ポインタ
			resultType.SetBasicType( GetPtrType( resultType.GetBasicType()^FLAG_PTR ) );
		}

		isLiteral = false;

		if( pIsVariable )
		{
			// 変数である
			*pIsVariable = true;
		}

		return true;
	}


	/////////////////////////////////
	// プロパティ用のメソッド
	/////////////////////////////////

	//配列要素を排除
	GetArrayElement(termFull,VarName,ArrayElements);

	if(GetSubHash(VarName,0)){
		GetReturnTypeOfPropertyMethod(termFull,NULL,resultType);

		isLiteral = false;

		return true;
	}


	return false;
}

bool GetTermType( const char *term, Type &resultType )
{
	bool isLiteral;
	return GetTermType( term, Type(), resultType, isLiteral );
}

bool GetTermTypeOnlyVariable( const char *term, Type &resultType )
{
	bool isLiteral, isVariable = false;
	bool result = GetTermType( term, Type(), resultType, isLiteral, NULL, &isVariable );
	return ( result && isVariable );
}

bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType, bool *pIsLiteralCalculation ){
	extern int cp;
	int i,i3;

	//リテラル値のみの計算かどうかを判別するためのフラグ
	bool dummyBool;
	if( pIsLiteralCalculation == NULL )
	{
		pIsLiteralCalculation = &dummyBool;
	}
	*pIsLiteralCalculation = true;

	if(expression[0]=='\0'){
		compiler.errorMessenger.Output(1,NULL,cp);
		return false;
	}

	if(expression[0]==1&& ( expression[1]==ESC_NEW || expression[1] == ESC_SYSTEM_STATIC_NEW ) ){
		//New演算子（オブジェクト生成）
		*pIsLiteralCalculation = false;
		return Operator_New_GetType(expression+2,baseType, resultType );
	}

	if( expression[0] == '[' ){
		if( !baseType.IsPointer() ){
			return false;
		}

		resultType = baseType;
		return true;
	}


	/////////////////////////////////
	// 式要素を逆ポーランド式で取得
	/////////////////////////////////

	char *values[255];
	long calc[255];
	long stack[255];
	int pnum;
	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
		for(i=0;i<pnum;i++){
			if(values[i]) HeapDefaultFree(values[i]);
		}
		return false;
	}



	////////////////////////////////
	// 演算部分のコード生成を開始
	////////////////////////////////

	BOOL bError;
	bError=0;

	int sp;
	int type_stack[255];
	LONG_PTR index_stack[255];
	bool isNothing_stack[255];
	_int64 i64data;
	int idCalc;
	for(i=0,sp=0;i<pnum;i++){
		idCalc=calc[i]%100;

		if(idCalc && sp >= 2){
			if(type_stack[sp-2]==DEF_OBJECT){
				if( idCalc == CALC_AS
					&& type_stack[sp-1] == ( DEF_OBJECT | FLAG_CAST )
					&& index_stack[sp-1] == index_stack[sp-2]
					|| isNothing_stack[sp-2] ){
						// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
				}
				else if( idCalc == CALC_AS
					&& type_stack[sp-1] == ( DEF_OBJECT | FLAG_CAST )
					&& ( ((CClass *)index_stack[sp-1])->IsEqualsOrSubClass( (CClass *)index_stack[sp-2] ) || ((CClass *)index_stack[sp-2])->IsEqualsOrSubClass( (CClass *)index_stack[sp-1] )
					)){
						// ダウンキャストを許可する
				}
				else if( idCalc == CALC_AS ){
					// NumOpe_GetTypeではすべてのキャストを許可する
				}
				else{
					//オーバーロードされたオペレータを呼び出す
					if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
						goto error;
					}

					continue;
				}
			}

			if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
		}

		switch(idCalc){
			//数値
			case 0:
				index_stack[sp]=-1;
				isNothing_stack[sp] = false;

				char *term;
				term = values[i];

				if( calc[i+1]%100 == CALC_AS ){
					// As演算子の右辺値
					//型名
					if( compiler.StringToType( term, resultType ) ){

						if( resultType.IsObject() ){
							if( resultType.GetClass().IsBlittableType() ){
								// Blittable型のときは基本型として扱う
								// ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
								if( compiler.IsLocalAreaCompiling()
									&& compiler.GetCompilingUserProc().HasParentClass()
									&& compiler.GetCompilingUserProc().GetParentClass().IsBlittableType() )
								{
									// コンパイル中のメソッドがBlittable型クラスに属している
								}
								else{
									resultType = resultType.GetClass().GetBlittableType();
								}
							}
						}

						resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
					}
					else{
						compiler.errorMessenger.Output(3, term, cp );
						goto error;
					}

					type_stack[sp] = resultType.GetBasicType();
					index_stack[sp] = resultType.GetIndex();
					sp++;

					break;
				}

				if(term[0]=='\"'){
StrLiteral:

					if( !baseType.IsPointer() ){
						//要求タイプがオブジェクト、または未定のとき
						type_stack[sp]=DEF_OBJECT;
						index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
						*pIsLiteralCalculation = false;

						sp++;
						break;
					}

					type_stack[sp]=typeOfPtrChar;
					*pIsLiteralCalculation = false;
				}
				else if((term[0]=='e'||term[0]=='E')&&
					(term[1]=='x'||term[1]=='X')&&
					term[2]=='\"'){
					//拡張版リテラル文字列（エスケープシーケンス可能）
					goto StrLiteral;
				}
				else if(IsVariableTopChar(term[0])||
					term[0]=='*'||
					(term[0]=='.'&&IsVariableTopChar(term[1])))
				{
					//////////////////
					// 何らかの識別子

					bool isLiteral = true;
					if( GetTermType( term, baseType, resultType, isLiteral ) ){
						type_stack[sp] = resultType.GetBasicType();
						index_stack[sp] = resultType.GetIndex();

						if( !isLiteral ){
							*pIsLiteralCalculation = false;
						}

						sp++;
						break;
					}


					// Nothing
					if( lstrcmp( term, "Nothing" ) == 0 ){
						isNothing_stack[sp] = true;

						if( baseType.IsObject() ){
							type_stack[sp] = DEF_OBJECT;
							index_stack[sp] = baseType.GetIndex();
						}
						else{
							type_stack[sp] = baseType.GetBasicType();
							index_stack[sp] = baseType.GetIndex();
						}

						*pIsLiteralCalculation = false;
						sp++;
						break;
					}


					//////////////
					// 定数の場合
					//////////////

					i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(
						ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( term )
					);
					if(i3){
						if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( ActiveBasic::Compiler::LexicalAnalyzer::FullNameToSymbol( term ), compiler.IsUnicode() ) )
						{
							//リテラル文字列
							goto StrLiteral;
						}

						type_stack[sp]=i3;
						if(IsRealNumberType(i3)){
							//実数
							goto Literal;
						}
						else if(IsWholeNumberType(i3)){
							//整数
							goto Literal;
						}
						else if(Is64Type(i3)){
							//64ビット整数値
							goto Literal;
						}
						else{
							compiler.errorMessenger.Output(1,NULL,0);
							goto error;
						}
					}


					/////////////////////////////////
					// プロパティ用のメソッド
					/////////////////////////////////

					//配列要素を排除
					char VarName[VN_SIZE],ArrayElements[VN_SIZE];
					GetArrayElement(term,VarName,ArrayElements);

					if(GetSubHash(VarName,0)){
						compiler.errorMessenger.OutputFatalError();
						Type tempType;
						GetReturnTypeOfPropertyMethod(term,NULL,tempType);

						//大きな型への暗黙の変換
						type_stack[sp]=tempType.GetBasicType();

						index_stack[sp]=tempType.GetIndex();
						*pIsLiteralCalculation = false;

						sp++;
						break;
					}



					//該当する識別子が見当たらないときはエラー扱いにする
					bError=1;
					compiler.errorMessenger.Output(3,term,cp);
					type_stack[sp]=DEF_DOUBLE;
				}
				else{
					//リテラル値
					int base_type = 0;
					if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
					type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
Literal:
					if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;
				}

				sp++;
				break;

			//論理演算子
			case CALC_XOR:
			case CALC_OR:
			case CALC_AND:
				sp--;
				type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
				break;
			case CALC_NOT:
				//values[sp-1]=Not values[sp-1]
				//NOT演算子
				break;

			//比較演算子
			case CALC_PE:		//values[sp-2] <= values[sp-1]
			case CALC_QE:		//values[sp-2] >= values[sp-1]
			case CALC_P:		//values[sp-2] <  values[sp-1]
			case CALC_Q:		//values[sp-2] >  values[sp-1]
			case CALC_NOTEQUAL:	//values[sp-2] <> values[sp-1]
			case CALC_EQUAL:	//values[sp-2] =  values[sp-1]	
				sp--;
				type_stack[sp-1]=DEF_LONG;
				break;

			//ビットシフト
			case CALC_SHL:	//values[sp-2] << values[sp-1]
			case CALC_SHR:	//values[sp-2] >> values[sp-1]
				sp--;
				break;

			//算術演算
			case CALC_ADDITION:
			case CALC_SUBTRACTION:
			case CALC_PRODUCT:
				sp--;
				type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
				break;
			case CALC_MOD:
				//values[sp-2]%=values[sp-1]
				//剰余演算
				sp--;
				type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
				break;
			case CALC_QUOTIENT:
				//values[sp-2]/=values[sp-1];
				//除算
				sp--;
				type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
				break;
			case CALC_INTQUOTIENT:
				//values[sp-2]/=values[sp-1]
				//整数除算
				sp--;
				type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
				break;
			case CALC_MINUSMARK:
				//values[sp-1]=-values[sp-1]
				//符号反転
				break;
			case CALC_POWER:
				//べき乗演算（浮動小数点演算のみ）
				sp--;
				//未完成
				break;
			case CALC_AS:
				//キャスト
				type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
				index_stack[sp-2]=index_stack[sp-1];

				sp--;
				break;

			case CALC_BYVAL:
				//ポインタ型→参照型
				if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
					//ポインタ型ではないとき
					compiler.errorMessenger.Output( 3, NULL, cp );
					goto error;
				}

				type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
				break;
		}
	}

	if(bError) goto error;

	if(sp!=1){
		compiler.errorMessenger.Output(1,NULL,cp);
		goto error;
	}

	if( *pIsLiteralCalculation ){
		//右辺値が数値の定数式の場合
		int base_type = 0;
		if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
		Type tempType;
		StaticCalculation(true, expression,base_type,&i64data,tempType);

		type_stack[0]=tempType.GetBasicType();
		index_stack[0]=tempType.GetIndex();
	}
	else{
		//右辺値が数値の定数式ではないとき
		if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
	}

	resultType.SetType( type_stack[0], index_stack[0] );

	bool isSuccessful = true;
	goto finish;


	//////////////////
	// エラー処理
	//////////////////

error:
	isSuccessful = false;
	goto finish;


finish:
	for(i=0;i<pnum;i++){
		if(values[i]) HeapDefaultFree(values[i]);
	}
	return isSuccessful;
}