Index: BasicCompiler32/NumOpe.cpp
===================================================================
--- BasicCompiler32/NumOpe.cpp	(revision 94)
+++ BasicCompiler32/NumOpe.cpp	(revision 97)
@@ -83,5 +83,431 @@
 }
 
-
+void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
+	if( reg != REG_EAX ){
+		SetError();
+	}
+	switch( Type::GetBasicSize( bigBasicType ) ){
+		case sizeof(_int64):
+			ExtendTypeTo64(baseBasicType);
+			break;
+		case sizeof(long):
+			ExtendTypeTo32(baseBasicType,reg);
+			break;
+		case sizeof(short):
+			ExtendTypeTo16(baseBasicType,reg);
+			break;
+	}
+}
+
+
+
+bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
+	const int useReg = REG_EAX;
+
+	//大きな型への暗黙の変換
+	int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+
+	if(resultType.GetBasicType()&FLAG_PTR){
+		//配列ポインタ
+		resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
+
+		SetVarPtrToReg(useReg, &relativeVar);
+	}
+	else if( resultType.IsStruct() ){
+		//構造体ポインタをeaxへ格納（構造体は値型）
+		SetVarPtrToReg(useReg, &relativeVar);
+	}
+	else if( resultType.IsReal() ){
+		// 実数
+		SetReg_RealVariable( resultType.GetBasicType(), &relativeVar );
+	}
+	else if( resultType.IsWhole() || resultType.IsObject()){
+		//整数型
+		SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,useReg);
+	}
+	else if( resultType.IsStruct() ){
+		//構造体ポインタをUseRegへ格納（構造体は値型）
+		SetVarPtrToReg(useReg,&relativeVar);
+	}
+	else{
+		return false;
+	}
+
+	if( resultType.GetBasicType() != bigType ){
+		// 大きな型へ変換された場合
+		// ※レジスタの値をキャストする
+		ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+		resultType.SetBasicType( bigType );
+	}
+
+	return true;
+}
+bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char *termFull, const char *termLeft, const char *member ){
+	const int useReg = REG_EAX;
+
+	if( GetMemberType( objClass, member, resultType, 0, false ) ){
+		// メンバが見つかったとき
+
+		//オブジェクトポインタをecxにコピー
+		op_mov_RR( REG_ECX, useReg );
+
+		RELATIVE_VAR relativeVar;
+		relativeVar.dwKind=VAR_DIRECTMEM;
+
+		if( !_member_offset(
+			true,	//エラー表示あり
+			false,	//読み込み専用
+			objClass,
+			member,&relativeVar,resultType,0)){
+				return false;
+		}
+
+		if( !VarToReg( relativeVar, baseType, resultType ) ){
+			SetError(11,termFull,cp);
+		}
+
+		return true;
+	}
+
+
+	///////////////////////////////////////////////////////////////////
+	// 動的メソッドを検索
+	///////////////////////////////////////////////////////////////////
+	vector<UserProc *> userProcs;
+
+	char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
+	CClass::RefType refType;
+	lstrcpy( methodName, member );
+	GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
+
+	objClass.EnumMethod( methodName, userProcs );
+	UserProc *pUserProc;
+	if(userProcs.size()){
+		//オーバーロードを解決
+		pUserProc=OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
+
+		if( pUserProc ){
+
+			resultType = pUserProc->ReturnType();
+
+			{
+				//オブジェクトポインタをスタックに入れておく
+				//push reg
+				op_push( useReg );
+
+				if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
+
+					return false;
+				}
+
+				op_pop();
+
+				/////////////////////
+				// 戻り値の処理
+				/////////////////////
+
+				//大きな型への暗黙の変換
+				int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+				if( resultType.GetBasicType() != bigType ){
+					// 大きな型へ変換された場合
+					// ※レジスタの値をキャストする
+					ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+					resultType.SetBasicType( bigType );
+				}
+
+				//SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+			}
+			
+			return true;
+		}
+	}
+
+	return false;
+}
+bool TermOpe( const char *term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL *pbUseHeap, bool *pIsClassName = NULL ){
+	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];
+	CClass::RefType refType;
+	if( SplitMemberName( termFull, termLeft, member, refType ) ){
+		///////////////////////////////////////////////////////////////////
+		// オブジェクトとメンバに分解できるとき
+		// termLeft.member
+		///////////////////////////////////////////////////////////////////
+
+		isLiteral = false;
+
+		// オブジェクト側の型を取得
+		bool isClassName = false;
+		Type leftType;
+		if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, &isClassName ) ){
+			return false;
+		}
+
+		if( isClassName ){
+			// 静的メンバ/メソッドの場合
+			goto globalArea;
+		}
+
+		if( !leftType.HasMember() ){
+			// メンバを持たない型の場合
+			return false;
+		}
+
+		return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
+	}
+
+
+	//////////////////////////////////////////////
+	// クラス名かどうかをチェック（静的メンバ用）
+	//////////////////////////////////////////////
+
+	if( pIsClassName ){
+		if( pobj_DBClass->check( termFull ) ){
+			*pIsClassName = true;
+			return true;
+		}
+	}
+
+
+	/////////////////////////////////////////////////////////////////
+	// グローバル属性エリア
+	/////////////////////////////////////////////////////////////////
+globalArea:
+
+	const int useReg = REG_EAX;
+
+
+	if(lstrcmpi(termFull,"This")==0){
+		//Thisオブジェクト
+		resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
+
+		SetThisPtrToReg( useReg );
+
+		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 *pInfo;
+		int idProc=GetProc(procName,(void **)&pInfo);
+
+		if(idProc){
+			//閉じカッコ")"に続く文字がNULLでないとき
+			if(termFull[i2+1+i4+1]!='\0'){
+				SetError(42,NULL,cp);
+			}
+
+
+			{
+				////////////////
+				// 呼び出し
+				////////////////
+
+				CallProc(idProc,pInfo,procName,parameter,resultType);
+
+
+				/////////////////////
+				// 戻り値の処理
+				/////////////////////
+
+				//大きな型への暗黙の変換
+				int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+				/*
+				※後でNumOpe内でプッシュする
+				//スタックへプッシュ
+				PushReturnValue( resultType.GetBasicType() );
+				*/
+
+				if( resultType.GetBasicType() != bigType ){
+					// 大きな型へ変換された場合
+					// ※レジスタの値をキャストする
+					ExtendRegToBigType( useReg, bigType, resultType.GetBasicType() );
+
+					resultType.SetBasicType( bigType );
+				}
+
+				//SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+			}
+
+
+			if(resultType.IsStruct()){
+				//構造体が戻ったときはヒープ領域にインスタンスが格納されている
+				//※後にfreeする必要あり
+				// TODO: 解放はGCに任せる
+				*pbUseHeap = 1;
+			}
+
+			isLiteral = false;
+
+			return true;
+		}
+		else if(GetConstCalcBuffer(procName,parameter,temporary)){
+			/////////////////////////
+			// マクロ関数
+			/////////////////////////
+
+			//閉じカッコ")"に続く文字がNULLでないときはエラーにする
+			if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
+
+			//マクロ関数の場合
+			NumOpe(useReg, temporary,Type(),resultType);
+
+			if(!IS_LITERAL(resultType.GetIndex())){
+				//リテラル値ではなかったとき
+				isLiteral = false;
+			}
+
+			return true;
+		}
+	}
+
+
+	////////////////////////////////
+	// インデクサ（getアクセサ）
+	////////////////////////////////
+
+	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
+	GetArrayElement(termFull,VarName,ArrayElements);
+	if(ArrayElements[0]){
+		GetVarType(VarName,resultType,false);
+		if( resultType.IsObject() ){
+			CallIndexerGetterProc(/*UseReg,*/&resultType.GetClass(),VarName,ArrayElements,resultType);
+
+			isLiteral = false;
+
+			return true;
+		}
+	}
+
+
+	////////////////////////////////
+	// 変数
+	////////////////////////////////
+
+	RELATIVE_VAR relativeVar;
+	if(GetVarOffset(
+		false,	//エラー表示なし
+		false,	//読み込み専用
+		termFull,
+		&relativeVar,resultType)){
+		//////////
+		// 変数
+		//////////
+
+		if( !VarToReg( relativeVar, baseType, resultType ) ){
+			SetError(11,termFull,cp);
+		}
+
+		isLiteral = false;
+
+		return true;
+	}
+
+
+	/////////////////////////////////
+	// プロパティ用のメソッド
+	/////////////////////////////////
+
+	//配列要素を排除
+	GetArrayElement(termFull,VarName,ArrayElements);
+
+	if(GetSubHash(VarName,0)){
+
+		{
+			CallPropertyMethod(termFull,NULL,resultType);
+
+			//大きな型への暗黙の変換
+			int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
+
+			if( resultType.GetBasicType() != bigType ){
+				// 大きな型へ変換された場合
+				// ※レジスタの値をキャストする
+				ExtendRegToBigType( REG_EAX, bigType, resultType.GetBasicType() );
+
+				resultType.SetBasicType( bigType );
+			}
+
+			//SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+		}
+
+
+		if(resultType.IsStruct()){
+			//構造体が戻ったときはヒープ領域にインスタンスが格納されている
+			//※後にfreeする必要あり
+			// TODO: 解放はGCに任せる
+			*pbUseHeap = 1;
+		}
+
+		isLiteral = false;
+
+		return true;
+	}
+
+
+	return false;
+}
+
+
+bool NumOpe( int reg,
+			const char *expression,
+			const Type &baseType,
+			Type &resultType,
+			BOOL *pbUseHeap ){
+
+	if( !NumOpe( expression, baseType, resultType, pbUseHeap ) ){
+		return false;
+	}
+
+	if( reg != REG_EAX ){
+		// TODO: 未実装
+		SetError();
+	}
+
+	if( resultType.IsReal() ){
+		//fld ptr[esp]
+		op_fld_ptr_esp( resultType.GetBasicType() );
+
+		//add esp,size
+		op_add_esp( resultType.GetBasicSize() );
+	}
+	else{
+		//pop eax
+		op_pop(REG_EAX);
+
+		if( resultType.Is64() ){
+			//pop edx
+			op_pop(REG_EDX);
+		}
+	}
+	return true;
+}
 bool NumOpe( const char *expression,
 			const Type &baseType,
@@ -89,6 +515,6 @@
 			BOOL *pbUseHeap ){
 
-	int i,i2,i3,i4;
-	char temporary[1024],temp2[1024],temp3[1024];
+	int i,i2,i3;
+	char temporary[1024],temp2[1024];
 
 	if(expression[0]=='\0'){
@@ -260,4 +686,22 @@
 				term=values[i];
 
+				if( calc[i+1]%100 == CALC_AS ){
+					// As演算子の右辺値
+					//型名
+					if( Type::StringToType( term, resultType ) ){
+						resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
+					}
+					else{
+						SetError(3, term, cp );
+						goto error;
+					}
+
+					type_stack[sp] = resultType.GetBasicType();
+					index_stack[sp] = resultType.GetIndex();
+					sp++;
+
+					break;
+				}
+
 				if(term[0]=='\"'){
 					//リテラル文字列
@@ -269,19 +713,17 @@
 StrLiteral:
 
-					if( baseType.IsObject() ){
-						if( baseType.IsStringObject() ){
-							//要求タイプがStringのとき
-
-							//String型オブジェクトを生成
-							NewStringObject(term);
-
-							extern CClass *pobj_StringClass;
-							type_stack[sp]=DEF_OBJECT;
-							index_stack[sp]=(LONG_PTR)pobj_StringClass;
-							bLiteralCalculation=0;
-
-							sp++;
-							break;
-						}
+					if( baseType.IsObject() || baseType.IsNull() ){
+						//要求タイプがオブジェクト、または未定のとき
+
+						//String型オブジェクトを生成
+						NewStringObject(term);
+
+						extern CClass *pobj_StringClass;
+						type_stack[sp]=DEF_OBJECT;
+						index_stack[sp]=(LONG_PTR)pobj_StringClass;
+						bLiteralCalculation=0;
+
+						sp++;
+						break;
 					}
 
@@ -317,119 +759,52 @@
 					// 何らかの識別子
 
-					//////////////////////////////////////
-					// 関数（DLL、ユーザー定義、組み込み）
-					//////////////////////////////////////
-
-					i2=GetCallProcName(term,temporary);
-					if(term[i2]=='('){
-						i4=GetStringInPare_RemovePare(temp2,term+i2+1);
-
-						void *pInfo;
-						int idProc=GetProc(temporary,(void **)&pInfo);
-
-						Type resultType;
-						if(idProc){
-							//閉じカッコ")"に続く文字がNULLでないとき
-							if(term[i2+1+i4+1]!='\0'){
-								if( term[i2+1+i4+1] == '.'
-									|| term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
-										goto NonProc;
+					bool isLiteral;
+					if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
+						if(resultType.IsNull()){
+							//戻り値が存在しないとき
+							for(i2=0;;i2++){
+								if(term[i2]=='('||term[i2]=='\0'){
+									term[i2]=0;
+									break;
+								}
+							}
+							SetError(38,term,cp);
+
+							goto error;
+						}
+
+						type_stack[sp] = resultType.GetBasicType();
+						index_stack[sp] = resultType.GetIndex();
+
+						if( !isLiteral ){
+							bLiteralCalculation=0;
+						}
+
+						if( resultType.GetBasicType() & FLAG_CAST ){
+							// 型名のみ
+							SetError();
+						}
+						else{
+							if( resultType.IsReal() ){
+								//sub esp,size
+								//fstp ptr[esp]
+								op_fstp_push( resultType );
+							}
+							else{
+								if( resultType.Is64() ){
+									//push edx
+									op_push( REG_EDX );
 								}
 								else{
-									SetError(42,NULL,cp);
+									ExtendTypeTo32( resultType.GetBasicType(), REG_EAX );
 								}
+
+								//push eax
+								op_push( REG_EAX );
 							}
-
-							////////////////
-							// 呼び出し
-							////////////////
-
-							CallProc(idProc,pInfo,temporary,temp2,resultType);
-							if(resultType.IsNull()){
-								//戻り値が存在しないとき
-								for(i2=2;;i2++){
-									if(term[i2]=='('||term[i2]=='\0'){
-										term[i2]=0;
-										break;
-									}
-								}
-								SetError(38,term,cp);
-
-								goto error;
-							}
-
-
-							/////////////////////
-							// 戻り値の処理
-							/////////////////////
-
-							//大きな型への暗黙の変換
-							type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-							index_stack[sp] = resultType.GetIndex();
-							bLiteralCalculation=0;
-
-							//スタックへプッシュ
-							PushReturnValue( resultType.GetBasicType() );
-
-							if( Is64Type(type_stack[sp])
-								&& resultType.IsWhole()
-								&& resultType.GetBasicSize() <= sizeof(long) ){
-									//必要に応じて64ビット拡張
-									ExtendStackTo64( resultType.GetBasicType() );
-							}
-
-							if( resultType.IsStruct() ){
-								//構造体が戻ったときはヒープ領域にインスタンスが格納されている
-								//※後にfreeする必要あり
-								bUseHeap[sp]=1;
-							}
-
-							sp++;
-							break;
 						}
-						else if(GetConstCalcBuffer(temporary,temp2,temp3)){
-							/////////////////////////
-							// マクロ関数
-							/////////////////////////
-
-							//閉じカッコ")"に続く文字がNULLでないときはエラーにする
-							if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
-
-							//マクロ関数の場合
-							NumOpe(temp3,Type(),resultType);
-
-							if(!IS_LITERAL(resultType.GetIndex())){
-								//リテラル値ではなかったとき
-								bLiteralCalculation=0;
-							}
-
-							type_stack[sp] = resultType.GetBasicType();
-							index_stack[sp] = resultType.GetIndex();
-
-							sp++;
-							break;
-						}
-					}
-NonProc:
-
-
-					//インデクサ（getアクセサ）
-					char variable[VN_SIZE],array_element[VN_SIZE];
-					GetArrayElement(term,variable,array_element);
-					if(array_element[0]){
-						Type resultType;
-						GetVarType(variable,resultType,0);
-						if( resultType.IsObject() ){
-							CallIndexerGetterProc(&resultType.GetClass(),variable,array_element,resultType);
-							type_stack[sp]=resultType.GetBasicType();
-							index_stack[sp]=resultType.GetIndex();
-							bLiteralCalculation=0;
-
-							//push eax
-							op_push(REG_EAX);
-
-							sp++;
-							break;
-						}
+
+						sp++;
+						break;
 					}
 
@@ -451,69 +826,4 @@
 						//push 0
 						op_push_V( 0 );
-
-						sp++;
-						break;
-					}
-
-					RELATIVE_VAR RelativeVar;
-					Type varType;
-					if(GetVarOffset(
-						false,	//エラー表示あり
-						false,	//読み込み専用
-						term,
-						&RelativeVar,varType)){
-						//////////
-						// 変数
-						//////////
-
-						//大きな型への暗黙の変換
-						type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
-						index_stack[sp] = varType.GetIndex();
-						bLiteralCalculation=0;
-
-						if(varType.GetBasicType()&FLAG_PTR){
-							//配列ポインタ
-							type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
-
-							SetVarPtrToEax(&RelativeVar);
-
-							//push eax
-							op_push(REG_EAX);
-						}
-						else if( varType.IsStruct() ){
-							//構造体ポインタをeaxへ格納（構造体は値型）
-							SetVarPtrToEax(&RelativeVar);
-
-							//push eax
-							op_push(REG_EAX);
-						}
-						else if( varType.GetBasicSize() == sizeof(_int64) ){
-							//64ビット型
-							PushDoubleVariable(&RelativeVar);
-						}
-						else if( varType.GetBasicSize() == sizeof(long) ){
-							//32ビット型
-							PushLongVariable(&RelativeVar);
-						}
-						else if( varType.IsInteger() ){
-							PushIntegerVariable(&RelativeVar);
-						}
-						else if( varType.IsWord() ){
-							PushWordVariable(&RelativeVar);
-						}
-						else if( varType.IsSByte() ){
-							PushCharVariable(&RelativeVar);
-						}
-						else if( varType.IsByte() || varType.IsBoolean() ){
-							PushByteVariable(&RelativeVar);
-						}
-						else SetError(11,term,cp);
-
-						if( Is64Type(type_stack[sp])
-							&& varType.IsWhole()
-							&& varType.GetBasicSize()<=sizeof(long)){
-							//必要に応じて64ビット拡張
-								ExtendStackTo64( varType.GetBasicType() );
-						}
 
 						sp++;
@@ -556,48 +866,4 @@
 
 
-					//////////////
-					// 型名の場合
-					//////////////
-					Type tempType;
-					if( Type::StringToType( term, tempType ) ){
-						type_stack[sp] = tempType.GetBasicType() | FLAG_CAST;
-						index_stack[sp] = tempType.GetIndex();
-						sp++;
-						break;
-					}
-
-
-					/////////////////////////////////
-					// プロパティ用のメソッド
-					/////////////////////////////////
-
-					//配列要素を排除
-					char VarName[VN_SIZE],ArrayElements[VN_SIZE];
-					GetArrayElement(term,VarName,ArrayElements);
-
-					if(GetSubHash(VarName,0)){
-						Type resultType;
-						CallPropertyMethod(term,NULL,resultType);
-
-						//大きな型への暗黙の変換
-						type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
-						index_stack[sp]=resultType.GetIndex();
-						bLiteralCalculation=0;
-
-						//スタックへプッシュ
-						PushReturnValue( resultType.GetBasicType() );
-
-						if(type_stack[sp]==DEF_STRUCT){
-							//構造体が戻ったときはヒープ領域にインスタンスが格納されている
-							//※後にfreeする必要あり
-							bUseHeap[sp]=1;
-						}
-
-						sp++;
-						break;
-					}
-
-
-
 					//該当する識別子が見当たらないときはエラー扱いにする
 					bError=1;
