Index: BasicCompiler_Common/BasicCompiler.h
===================================================================
--- BasicCompiler_Common/BasicCompiler.h	(revision 71)
+++ BasicCompiler_Common/BasicCompiler.h	(revision 73)
@@ -24,5 +24,5 @@
 DWORD ImageBase;
 INCLUDEFILEINFO IncludeFileInfo;
-SUBINFO **ppSubHash;
+SubInfo **ppSubHash;
 int SubNum;
 char **ppMacroNames;
Index: BasicCompiler_Common/Class.cpp
===================================================================
--- BasicCompiler_Common/Class.cpp	(revision 71)
+++ BasicCompiler_Common/Class.cpp	(revision 73)
@@ -267,5 +267,5 @@
 	staticMembers.push_back( member );
 }
-void CClass::AddMethod( SUBINFO *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
+void CClass::AddMethod( SubInfo *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
 	CMethod *method = new CMethod();
 	method->psi = psi;
@@ -278,5 +278,5 @@
 	methods.push_back( method );
 }
-void CClass::AddStaticMethod(SUBINFO *psi,DWORD dwAccess){
+void CClass::AddStaticMethod(SubInfo *psi,DWORD dwAccess){
 	CMethod *method = new CMethod();
 	method->psi=psi;
@@ -322,5 +322,5 @@
 	return 0;
 }
-CMethod *CClass::GetMethodInfo( SUBINFO *psi ){
+CMethod *CClass::GetMethodInfo( SubInfo *psi ){
 	for( int i=(int)methods.size()-1; i>=0; i-- ){
 		if( psi == methods[i]->psi ) return methods[i];
@@ -328,5 +328,5 @@
 	return NULL;
 }
-CMethod *CClass::GetStaticMethodInfo( SUBINFO *psi ){
+CMethod *CClass::GetStaticMethodInfo( SubInfo *psi ){
 	for( int i=(int)staticMethods.size()-1; i>=0; i-- ){
 		if( psi == staticMethods[i]->psi ) return staticMethods[i];
@@ -347,5 +347,5 @@
 }
 
-void CClass::EnumStaticMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
+void CClass::EnumStaticMethod( const char *methodName, std::vector<SubInfo *> &subs ) const
 {
 	foreach( CMethod *method, staticMethods ){
@@ -356,5 +356,5 @@
 }
 
-void CClass::EnumMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
+void CClass::EnumMethod( const char *methodName, std::vector<SubInfo *> &subs ) const
 {
 	//オブジェクトのメンバ関数の場合
@@ -367,10 +367,10 @@
 }
 
-void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<SUBINFO *> &subs ) const
+void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<SubInfo *> &subs ) const
 {
 	//オブジェクトのメンバ関数の場合
 	//※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
 	for( int i=(int)methods.size()-1; i>=0; i-- ){
-		SUBINFO *psi = methods[i]->psi;
+		SubInfo *psi = methods[i]->psi;
 		char *temp = psi->name;
 		if(temp[0]==1&&temp[1]==ESC_OPERATOR){
@@ -508,5 +508,5 @@
 
 
-int CClass::GetFuncNumInVtbl( const SUBINFO *psi ) const
+int CClass::GetFuncNumInVtbl( const SubInfo *psi ) const
 {
 	int n = 0;
@@ -527,6 +527,6 @@
 	//////////////////////////////////////
 
-	SUBINFO **ppsi;
-	ppsi=(SUBINFO **)HeapAlloc(hHeap,0,vtbl_num*sizeof(SUBINFO *));
+	SubInfo **ppsi;
+	ppsi=(SubInfo **)HeapAlloc(hHeap,0,vtbl_num*sizeof(SubInfo *));
 
 	//関数テーブルに値をセット
@@ -565,6 +565,6 @@
 	int i;
 	for(i=0;i<vtbl_num;i++){
-		SUBINFO *psi;
-		psi=(SUBINFO *)pVtbl[i];
+		SubInfo *psi;
+		psi=(SubInfo *)pVtbl[i];
 		if(!psi) continue;
 		pVtbl[i]=psi->CompileAddress+ImageBase+MemPos_CodeSection;
@@ -835,5 +835,5 @@
 
 	//関数ハッシュへ登録
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi=AddSubData(buffer,NowLine,bVirtual,pobj_c,bStatic);
 	if(!psi) return;
@@ -849,5 +849,5 @@
 
 		//標準コンストラクタ（引数なし）
-		if(psi->ParmNum==0) fConstructor=1;
+		if(psi->params.size()==0) fConstructor=1;
 
 		//強制的にConst修飾子をつける
@@ -894,8 +894,5 @@
 
 		if(lstrcmp(temporary,method->psi->name)==0){
-			if(CompareParameter(
-				method->psi->pParmInfo,method->psi->ParmNum,
-				psi->pParmInfo,psi->ParmNum
-				)==0){
+			if( Parameter::Equals( method->psi->params, psi->params ) ){
 				//関数名、パラメータ属性が合致したとき
 				SetError(15,psi->name,NowLine);
@@ -911,8 +908,5 @@
 	foreach( CMethod *method, pobj_c->methods ){
 		if(lstrcmp(temporary,method->psi->name)==0){
-			if(CompareParameter(
-				method->psi->pParmInfo,method->psi->ParmNum,
-				psi->pParmInfo,psi->ParmNum
-				)==0){
+			if( Parameter::Equals( method->psi->params, psi->params ) ){
 
 				if(method->psi->bVirtual){
@@ -1444,5 +1438,5 @@
 }
 
-void CDBClass::StartCompile( SUBINFO *psi ){
+void CDBClass::StartCompile( SubInfo *psi ){
 	pCompilingClass = psi->pobj_ParentClass;
 	if( pCompilingClass ){
Index: BasicCompiler_Common/Class.h
===================================================================
--- BasicCompiler_Common/Class.h	(revision 71)
+++ BasicCompiler_Common/Class.h	(revision 73)
@@ -2,5 +2,5 @@
 
 class CClass;
-struct SUBINFO;
+class SubInfo;
 
 //データ型
@@ -48,5 +48,5 @@
 class CMethod{
 public:
-	SUBINFO *psi;
+	SubInfo *psi;
 	DWORD dwAccess;
 	BOOL bAbstract;
@@ -116,6 +116,6 @@
 	void AddMember( DWORD dwAccess, bool idConst, bool isRef, char *buffer );
 	void AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int NowLine );
-	void AddMethod( SUBINFO *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual );
-	void AddStaticMethod(SUBINFO *psi,DWORD dwAccess);
+	void AddMethod( SubInfo *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual );
+	void AddStaticMethod(SubInfo *psi,DWORD dwAccess);
 
 	//重複チェック
@@ -124,6 +124,6 @@
 
 	//メソッド取得
-	CMethod *GetMethodInfo( SUBINFO *psi );
-	CMethod *GetStaticMethodInfo( SUBINFO *psi );
+	CMethod *GetMethodInfo( SubInfo *psi );
+	CMethod *GetStaticMethodInfo( SubInfo *psi );
 
 	//メソッドの存在を確認
@@ -132,7 +132,7 @@
 
 	//メソッドを列挙
-	void EnumStaticMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const;
-	void EnumMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const;
-	void EnumMethod( const BYTE idOperatorCalc, std::vector<SUBINFO *> &subs ) const;
+	void EnumStaticMethod( const char *methodName, std::vector<SubInfo *> &subs ) const;
+	void EnumMethod( const char *methodName, std::vector<SubInfo *> &subs ) const;
+	void EnumMethod( const BYTE idOperatorCalc, std::vector<SubInfo *> &subs ) const;
 
 	//デフォルト コンストラクタ メソッドを取得
@@ -157,5 +157,5 @@
 	long vtbl_offset;
 public:
-	int GetFuncNumInVtbl( const SUBINFO *psi ) const;
+	int GetFuncNumInVtbl( const SubInfo *psi ) const;
 	LONG_PTR GetVtblGlobalOffset(void);
 	void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection);
@@ -245,5 +245,5 @@
 public:
 	//コンパイル開始の通知を受け取るメソッド
-	void StartCompile( SUBINFO *psi );
+	void StartCompile( SubInfo *psi );
 
 	//現在コンパイル中のメソッド情報を取得
Index: BasicCompiler_Common/Debug.cpp
===================================================================
--- BasicCompiler_Common/Debug.cpp	(revision 71)
+++ BasicCompiler_Common/Debug.cpp	(revision 73)
@@ -224,7 +224,7 @@
 	SendDlgItemMessage(hMainDlg,IDC_DEBUGLIST,EM_REPLACESEL,0,(LPARAM)buffer);
 }
-SUBINFO *GetSubFromObp(ULONG_PTR pos){
-	extern SUBINFO **ppSubHash;
-	SUBINFO *psi;
+SubInfo *GetSubFromObp(ULONG_PTR pos){
+	extern SubInfo **ppSubHash;
+	SubInfo *psi;
 	int i2;
 
@@ -447,5 +447,5 @@
 	pobj_dti=new CDebugThreadInfo();
 
-	SUBINFO *psi;
+	SubInfo *psi;
 
 	extern DWORD dwStepRun;
@@ -681,5 +681,5 @@
 						if(!bRet) MessageBox(hMainDlg,"プロセスメモリーの読み込みに失敗","error",MB_OK);
 
-						extern SUBINFO *pSub_DebugSys_EndProc;
+						extern SubInfo *pSub_DebugSys_EndProc;
 						if((BYTE)temporary[0]==0xE8&&
 							*((long *)(temporary+1))+5==(long)rva_to_real(pSub_DebugSys_EndProc->CompileAddress)-(long)EIP_RIP(Context)){
Index: BasicCompiler_Common/DebugMiddleFile.cpp
===================================================================
--- BasicCompiler_Common/DebugMiddleFile.cpp	(revision 71)
+++ BasicCompiler_Common/DebugMiddleFile.cpp	(revision 73)
@@ -213,7 +213,7 @@
 
 	//プロシージャ情報
-	extern SUBINFO **ppSubHash;
+	extern SubInfo **ppSubHash;
 	extern int SubNum;
-	SUBINFO *psi;
+	SubInfo *psi;
 	*(long *)(buffer+i2)=SubNum;
 	i2+=sizeof(long);
@@ -585,10 +585,10 @@
 
 	//プロシージャ情報
-	SUBINFO *psi;
+	SubInfo *psi;
 	SubNum=*(long *)(buffer+i2);
 	i2+=sizeof(long);
-	ppSubHash=(SUBINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SUBINFO *));
+	ppSubHash=(SubInfo **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SubInfo *));
 	for(i3=0;i3<SubNum;i3++){
-		psi=(SUBINFO *)HeapAlloc(hHeap,0,sizeof(SUBINFO));
+		psi = new SubInfo();
 		psi->pNextData=0;
 
@@ -618,8 +618,4 @@
 		i2+=sizeof(long);
 
-		psi->ParmNum=0;
-		psi->pParmInfo=0;
-		psi->RealParmNum=0;
-		psi->pRealParmInfo=0;
 		psi->bCompile=1;
 
@@ -677,5 +673,5 @@
 		i4=hash_default(psi->name);
 
-		SUBINFO *psi2;
+		SubInfo *psi2;
 		if(ppSubHash[i4]){
 			psi2=ppSubHash[i4];
@@ -804,5 +800,5 @@
 
 
-	extern SUBINFO **ppSubHash;
+	extern SubInfo **ppSubHash;
 	ppSubHash=this->ppSubHash;
 	pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc");
@@ -973,10 +969,10 @@
 	extern char **ppMacroNames;
 	ppMacroNames=0;
-	extern SUBINFO **ppSubHash;
+	extern SubInfo **ppSubHash;
 	extern int SubNum;
 	ppSubHash=this->ppSubHash;
 	SubNum=this->SubNum;
 
-	extern SUBINFO *pSub_DebugSys_EndProc;
+	extern SubInfo *pSub_DebugSys_EndProc;
 	pSub_DebugSys_EndProc=this->pSub_DebugSys_EndProc;
 
@@ -998,5 +994,5 @@
 
 	//ローカル変数に関する情報を解放
-	SUBINFO *psi;
+	SubInfo *psi;
 	for(i2=0;i2<MAX_HASH;i2++){
 		psi=ppSubHash[i2];
Index: BasicCompiler_Common/DebugSection.h
===================================================================
--- BasicCompiler_Common/DebugSection.h	(revision 71)
+++ BasicCompiler_Common/DebugSection.h	(revision 73)
@@ -49,8 +49,8 @@
 
 	//プロシージャ
-	SUBINFO **ppSubHash;
+	SubInfo **ppSubHash;
 	int SubNum;
 
-	SUBINFO *pSub_DebugSys_EndProc;
+	SubInfo *pSub_DebugSys_EndProc;
 
 	//ネイティブコードバッファ
Index: BasicCompiler_Common/LexicalScoping.cpp
===================================================================
--- BasicCompiler_Common/LexicalScoping.cpp	(revision 71)
+++ BasicCompiler_Common/LexicalScoping.cpp	(revision 73)
@@ -226,5 +226,5 @@
 
 			//call free
-			extern SUBINFO *pSub_free;
+			extern SubInfo *pSub_free;
 			op_call(pSub_free);
 
Index: BasicCompiler_Common/MakeExe.cpp
===================================================================
--- BasicCompiler_Common/MakeExe.cpp	(revision 71)
+++ BasicCompiler_Common/MakeExe.cpp	(revision 73)
@@ -223,6 +223,6 @@
 
 	//ローカル変数に関する情報を解放
-	extern SUBINFO **ppSubHash;
-	SUBINFO *psi;
+	extern SubInfo **ppSubHash;
+	SubInfo *psi;
 	for(i2=0;i2<MAX_HASH;i2++){
 		psi=ppSubHash[i2];
@@ -238,5 +238,5 @@
 
 	//サブルーチン（ユーザー定義）情報のメモリ解放
-	extern SUBINFO **ppSubHash;
+	extern SubInfo **ppSubHash;
 	extern char **ppMacroNames;
 	extern int MacroNum;
Index: BasicCompiler_Common/NumOpe_GetType.cpp
===================================================================
--- BasicCompiler_Common/NumOpe_GetType.cpp	(revision 71)
+++ BasicCompiler_Common/NumOpe_GetType.cpp	(revision 73)
@@ -193,5 +193,5 @@
 	pobj_c=(CClass *)index_stack[sp-2];
 
-	std::vector<SUBINFO *> subs;
+	std::vector<SubInfo *> subs;
 	pobj_c->EnumMethod( idCalc, subs );
 	if( subs.size() == 0 ){
@@ -230,5 +230,5 @@
 	if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
 	else GetCalcName(idCalc,temporary);
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
 
@@ -240,5 +240,5 @@
 	else{
 		//オーバーロードされていないが、パラメータ個数が一致しないとき
-		if(iParmNum!=psi->ParmNum){
+		if(iParmNum!=psi->params.size()){
 			HeapDefaultFree(ppi);
 			return 0;
@@ -299,5 +299,5 @@
 }
 
-int NumOpe_GetType(char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex){
+int NumOpe_GetType_Old( const char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex){
 	extern int cp;
 	int i,i2,i3,i4;
@@ -454,5 +454,5 @@
 
 							//マクロ関数の場合
-							i2=NumOpe_GetType(temp3,NULL,&index_stack[sp]);
+							i2=NumOpe_GetType_Old(temp3,NULL,&index_stack[sp]);
 
 							if(!IS_LITERAL(index_stack[sp])){
@@ -740,2 +740,18 @@
 	return RetType;
 }
+
+bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
+	TYPEINFO baseTypeInfo = {
+		baseType.GetBasicType(),
+		baseType.GetIndex()
+	};
+	LONG_PTR lpIndex;
+	int basicType = NumOpe_GetType_Old( expression,
+		baseType.IsNull() ? NULL:&baseTypeInfo,
+		&lpIndex );
+
+	resultType.SetBasicType( basicType );
+	resultType.SetIndex( lpIndex );
+
+	return ( basicType != -1 );
+}
Index: BasicCompiler_Common/Object.cpp
===================================================================
--- BasicCompiler_Common/Object.cpp	(revision 71)
+++ BasicCompiler_Common/Object.cpp	(revision 73)
@@ -19,5 +19,5 @@
 	pobj_c=(CClass *)TypeInfo.u.lpIndex;
 
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi=GetMethodHash(ObjectName,pobj_c->name,Parameter);
 	if(!psi){
Index: BasicCompiler_Common/Overload.cpp
===================================================================
--- BasicCompiler_Common/Overload.cpp	(revision 71)
+++ BasicCompiler_Common/Overload.cpp	(revision 73)
@@ -7,7 +7,7 @@
 #endif
 
-SUBINFO *OverloadSolutionWithStrParam(
+SubInfo *OverloadSolutionWithStrParam(
 	const char *name,
-	std::vector<SUBINFO *> &subs,
+	std::vector<SubInfo *> &subs,
 	const char *Parameter,
 	const char *ObjectName,
@@ -37,9 +37,12 @@
 */
 		//パラメータオブジェクトを生成
+		if(lstrcmp(Parameter,"\"test\"")==0){
+			int i=0;
+		}
 		pobj_parameter=new ParamImpl(Parameter);
 		if(pReturnTypeInfo) pobj_parameter->SetReturnType(pReturnTypeInfo);
 
 
-		SUBINFO *psi;
+		SubInfo *psi;
 		psi=pobj_parameter->OverloadSolution(name,subs);
 
@@ -52,7 +55,7 @@
 }
 
-SUBINFO *OverloadSolution(
+SubInfo *OverloadSolution(
 	const char *name,
-	std::vector<SUBINFO *> &subs,
+	std::vector<SubInfo *> &subs,
 	const PARAMETER_INFO *ppi,
 	const int ParmNum,
@@ -68,5 +71,5 @@
 		if(pReturnTypeInfo) pobj_Parameter->SetReturnType(pReturnTypeInfo);
 
-		SUBINFO *psi;
+		SubInfo *psi;
 		psi=pobj_Parameter->OverloadSolution(name,subs);
 
Index: BasicCompiler_Common/PESchedule.cpp
===================================================================
--- BasicCompiler_Common/PESchedule.cpp	(revision 71)
+++ BasicCompiler_Common/PESchedule.cpp	(revision 73)
@@ -220,5 +220,5 @@
 
 CSubAddrSchedule::CSubAddrSchedule(){
-	ppsi=(SUBINFO **)HeapAlloc(hHeap,0,1);
+	ppsi=(SubInfo **)HeapAlloc(hHeap,0,1);
 	pbCall=(BOOL *)HeapAlloc(hHeap,0,1);
 }
@@ -228,8 +228,8 @@
 }
 
-void CSubAddrSchedule::add(SUBINFO *psi,BOOL bCall){
+void CSubAddrSchedule::add(SubInfo *psi,BOOL bCall){
 	if(!psi) return;
 
-	ppsi=(SUBINFO **)HeapReAlloc(hHeap,0,ppsi,(num+1)*sizeof(SUBINFO *));
+	ppsi=(SubInfo **)HeapReAlloc(hHeap,0,ppsi,(num+1)*sizeof(SubInfo *));
 	ppsi[num]=psi;
 	pbCall=(BOOL *)HeapReAlloc(hHeap,0,pbCall,(num+1)*sizeof(BOOL));
@@ -282,2 +282,3 @@
 CTempSchedule *pobj_TempSchedule;
 
+
Index: BasicCompiler_Common/PESchedule.h
===================================================================
--- BasicCompiler_Common/PESchedule.h	(revision 71)
+++ BasicCompiler_Common/PESchedule.h	(revision 73)
@@ -79,5 +79,5 @@
 class CSubAddrSchedule:public CSchedule{
 public:
-	SUBINFO **ppsi;
+	SubInfo **ppsi;
 	BOOL *pbCall;
 
@@ -85,5 +85,5 @@
 	~CSubAddrSchedule();
 
-	void add(SUBINFO *psi,BOOL bCall);
+	void add(SubInfo *psi,BOOL bCall);
 };
 extern CSubAddrSchedule *pobj_SubAddrSchedule;
Index: BasicCompiler_Common/ParamImpl.cpp
===================================================================
--- BasicCompiler_Common/ParamImpl.cpp	(revision 71)
+++ BasicCompiler_Common/ParamImpl.cpp	(revision 73)
@@ -73,4 +73,16 @@
 	ReturnTypeInfo.u.lpIndex=-1;
 }
+ParamImpl::ParamImpl(const Parameters &params){
+	int count = 0;
+	foreach( Parameter *pParam, params ){
+		types[count].type = pParam->GetBasicType();
+		types[count].u.lpIndex = pParam->GetIndex();
+		count++;
+	}
+	this->ParmsNum=params.size();
+
+	ReturnTypeInfo.type=DEF_NON;
+	ReturnTypeInfo.u.lpIndex=-1;
+}
 ParamImpl::~ParamImpl(){
 	int i2;
@@ -88,25 +100,27 @@
 }
 
-BOOL ParamImpl::_overload_check(PARAMETER_INFO *ppi,int pi_num,TYPEINFO *pReturnTypeInfo,int overload_level){
+BOOL ParamImpl::_overload_check( Parameters &params,TYPEINFO *pReturnTypeInfo,int overload_level){
 	//パラメータを識別してオーバーロードを解決
 
 	//パラメータの個数が不一致の場合
-	if(pi_num!=ParmsNum) return 0;
-
-	int i,type;
-	LONG_PTR lpIndex;
-	for(i=0;i<pi_num;i++){
+	int max = (int)params.size();
+	if(max!=ParmsNum) return 0;
+
+	Type argType;
+	for(int i=0;i<max;i++){
+		Parameter &param = *params[i];
+
 		if(Parms[i]){
-			TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
-			type=NumOpe_GetType(Parms[i],
-				(overload_level==OVERLOAD_LEVEL0) ? NULL : &BaseType,
-				&lpIndex);
+			Type nullParam( DEF_NON );
+
+			NumOpe_GetType(Parms[i],
+				(overload_level==OVERLOAD_LEVEL0)? nullParam : param,
+				argType);
 		}
 		else{
-			type=types[i].type;
-			lpIndex=types[i].u.lpIndex;
-		}
-
-		if(type!=ppi[i].type){
+			argType.SetType( types[i].type, types[i].u.lpIndex );
+		}
+
+		if(argType.GetBasicType()!=param.GetBasicType()){
 			if(overload_level==OVERLOAD_LEVEL1 || overload_level == OVERLOAD_LEVEL0){
 				return 0;
@@ -114,15 +128,15 @@
 			else if(overload_level==OVERLOAD_LEVEL2){
 				if(!(
-					IsWholeNumberType(type)&&IsWholeNumberType(ppi[i].type)||
-					IsRealNumberType(type)&&IsRealNumberType(ppi[i].type)
+					IsWholeNumberType(argType.GetBasicType())&&IsWholeNumberType(param.GetBasicType())||
+					IsRealNumberType(argType.GetBasicType())&&IsRealNumberType(param.GetBasicType())
 					)) return 0;
 			}
 			else if(overload_level==OVERLOAD_LEVEL3){
-				if(type==DEF_OBJECT||ppi[i].type==DEF_OBJECT) return 0;
+				if(argType.GetBasicType()==DEF_OBJECT||param.GetBasicType()==DEF_OBJECT) return 0;
 			}
 		}
 		else{
-			if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
-				if(lpIndex!=ppi[i].u.index) return 0;
+			if(NATURAL_TYPE(argType.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(argType.GetBasicType())==DEF_STRUCT){
+				if(argType.GetIndex()!=param.GetIndex()) return 0;
 			}
 		}
@@ -143,11 +157,11 @@
 }
 
-SUBINFO *ParamImpl::OverloadSolutionWithReturnType( const char *name, std::vector<SUBINFO *> &subs ){
+SubInfo *ParamImpl::OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs ){
 	int sw=0;
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi=0;
 
 	for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
-		foreach( SUBINFO *temp_psi, subs ){
+		foreach( SubInfo *temp_psi, subs ){
 
 			TYPEINFO ReturnTypeInfo;
@@ -156,5 +170,5 @@
 
 			//エラーチェック
-			if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,&ReturnTypeInfo,level)){
+			if(_overload_check(temp_psi->params,&ReturnTypeInfo,level)){
 				if(sw){
 					SetError(52,name,cp);
@@ -178,15 +192,15 @@
 	return psi;
 }
-SUBINFO *ParamImpl::OverloadSolution( const char *name, std::vector<SUBINFO *> &subs ){
+SubInfo *ParamImpl::OverloadSolution( const char *name, std::vector<SubInfo *> &subs ){
 	int sw=0;
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi=0;
 
 	for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
 
-		foreach( SUBINFO *temp_psi, subs ){
+		foreach( SubInfo *temp_psi, subs ){
 
 			//エラーチェック
-			if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,NULL,level)){
+			if(_overload_check(temp_psi->params,NULL,level)){
 				if(sw){
 					return OverloadSolutionWithReturnType(name,subs);
@@ -202,9 +216,9 @@
 
 	if(!sw){
-		SUBINFO *temp_psi;
+		SubInfo *temp_psi;
 		foreach( temp_psi, subs ){
 
 			//エラーチェック
-			if(temp_psi->ParmNum==this->ParmsNum){
+			if(temp_psi->params.size()==this->ParmsNum){
 				if(sw){
 					sw=0;
@@ -258,8 +272,39 @@
 	return 1;
 }
+bool ParamImpl::ErrorCheck( const char *procName, const Parameters &params, int SecondParmNum ){
+	if(ParmsNum>(int)params.size()){
+		if(params[params.size()-1]->GetBasicType()!=DEF_ELLIPSE){
+			//パラメータが多すぎるとき
+			SetError(10,procName,cp);
+			return false;
+		}
+	}
+	else if(ParmsNum<(int)params.size()){
+		if(ParmsNum<SecondParmNum){
+			if(params[ParmsNum]->GetBasicType()==DEF_ELLIPSE){
+				return true;
+			}
+
+			//パラメータが少なすぎるとき
+			SetError(10,procName,cp);
+			return false;
+		}
+
+		//省略パラメータに "0" を指定する
+		for(;ParmsNum < (int)params.size();ParmsNum++){
+			extern HANDLE hHeap;
+			char temporary[64];
+			if(params[ParmsNum]->IsRef() == false) lstrcpy(temporary,"0");
+			else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
+			Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
+			lstrcpy(Parms[ParmsNum],temporary);
+		}
+	}
+
+	return true;
+}
 
 void ParamImpl::MacroParameterSupport(PARAMETER_INFO *ppi){
-	int i;
-	for(i=0;i<ParmsNum;i++){
+	for(int i=0;i<ParmsNum;i++){
 		if(Parms[i][0]=='\0'){
 			extern HANDLE hHeap;
@@ -273,2 +318,15 @@
 	}
 }
+void ParamImpl::MacroParameterSupport( const Parameters &params ){
+	for(int i=0;i<ParmsNum;i++){
+		if(Parms[i][0]=='\0'){
+			extern HANDLE hHeap;
+			char temporary[64];
+			if( params[i]->IsRef() == false ) lstrcpy(temporary,"0");
+			else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
+			HeapDefaultFree(Parms[i]);
+			Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
+			lstrcpy(Parms[i],temporary);
+		}
+	}
+}
Index: BasicCompiler_Common/Parameter.h
===================================================================
--- BasicCompiler_Common/Parameter.h	(revision 71)
+++ BasicCompiler_Common/Parameter.h	(revision 73)
@@ -5,5 +5,5 @@
 
 class Parameter;
-typedef vector<Parameter> Parameters;
+typedef vector<Parameter *> Parameters;
 
 class Parameter : public Type
@@ -16,9 +16,21 @@
 public:
 	Parameter( const string &varName, const Type &type, bool isRef = false ):
-		Type( type )
+		Type( type ),
+		varName( varName ),
+		isRef( isRef ),
+		isArray( false )
 	{
-		this->varName = varName;
-		this->isRef = isRef;
-		isArray = false;
+		subScripts[0] = -1;
+	}
+	Parameter( const Parameter &param ):
+		Type( param ),
+		varName( param.varName ),
+		isRef( param.isRef ),
+		isArray( false )
+	{
+		subScripts[0] = -1;
+		if( param.isArray ){
+			SetArray( param.subScripts );
+		}
 	}
 	~Parameter(){}
@@ -27,4 +39,9 @@
 		isArray = true;
 		memcpy( this->subScripts, pSubScripts, sizeof(int) * MAX_ARRAYDIM );
+	}
+
+	const string &GetVarName() const
+	{
+		return varName;
 	}
 
@@ -46,9 +63,9 @@
 		else{
 
-			if( this->isRef && this->BasicType() == DEF_ANY &&
+			if( this->isRef && this->GetBasicType() == DEF_ANY &&
 				param.isRef == false && param.IsPointer()
 				||
 				this->isRef == false && this->IsPointer() &&
-				param.isRef && param.BasicType() == DEF_ANY ){
+				param.isRef && param.GetBasicType() == DEF_ANY ){
 					/* ByRef var As Any
 							と
@@ -71,5 +88,5 @@
 		int max = (int)paramsA.size();
 		for( int i=0; i<max; i++ ){
-			if( !paramsA[i].Equals( paramsB[i] ) ){
+			if( !paramsA[i]->Equals( *paramsB[i] ) ){
 				return false;
 			}
Index: BasicCompiler_Common/Subroutine.cpp
===================================================================
--- BasicCompiler_Common/Subroutine.cpp	(revision 71)
+++ BasicCompiler_Common/Subroutine.cpp	(revision 73)
@@ -8,5 +8,5 @@
 
 //コンパイル中の関数情報
-SUBINFO *pCompilingSubInfo;
+SubInfo *pCompilingSubInfo;
 
 int GetCallProcName(char *buffer,char *name){
@@ -114,9 +114,9 @@
 		/////////////////////
 
-		SUBINFO *psi;
-		psi=(SUBINFO *)pInfo;
+		SubInfo *pSub;
+		pSub=(SubInfo *)pInfo;
 
 		//GetSubHash内でエラー提示が行われた場合
-		if(psi==(SUBINFO *)-1) return -1;
+		if(pSub==(SubInfo *)-1) return -1;
 
 
@@ -131,19 +131,19 @@
 		////////////////////////
 
-		std::vector<SUBINFO *> subs;
+		std::vector<SubInfo *> subs;
 		GetOverloadSubHash(name,subs);
 		if(subs.size()){
 			//オーバーロードを解決
-			psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
-
-			if(!psi) return 0;
-		}
-
-
-		Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
+			pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
+
+			if(!pSub) return 0;
+		}
+
+
+		Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
 		if( plpRetIndex ){
-			*plpRetIndex = psi->u.ReturnIndex;
-		}
-		return psi->ReturnType;
+			*plpRetIndex = pSub->u.ReturnIndex;
+		}
+		return pSub->ReturnType;
 	}
 	else if(idProc==PROC_DLL){
@@ -197,5 +197,5 @@
 
 	//オーバーロード用の関数リストを作成
-	std::vector<SUBINFO *> subs;
+	std::vector<SubInfo *> subs;
 	GetOverloadSubHash(VarName,subs);
 	if(subs.size()==0){
@@ -213,14 +213,14 @@
 
 	//オーバーロードを解決
-	SUBINFO *psi;
-	psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
-
-	if(psi){
+	SubInfo *pSub;
+	pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
+
+	if(pSub){
 		//呼び出し
-		Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
+		Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
 
 		if( pRetTypeInfo ){
-			pRetTypeInfo->type = psi->ReturnType;
-			pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
+			pRetTypeInfo->type = pSub->ReturnType;
+			pRetTypeInfo->u.lpIndex = pSub->u.ReturnIndex;
 		}
 	}
@@ -240,9 +240,9 @@
 		/////////////////////
 
-		SUBINFO *psi;
-		psi=(SUBINFO *)pInfo;
+		SubInfo *pSub;
+		pSub=(SubInfo *)pInfo;
 
 		//GetSubHash内でエラー提示が行われた場合
-		if(psi==(SUBINFO *)-1) return -1;
+		if(pSub==(SubInfo *)-1) return -1;
 
 
@@ -257,16 +257,16 @@
 		////////////////////////
 
-		std::vector<SUBINFO *> subs;
+		std::vector<SubInfo *> subs;
 		GetOverloadSubHash(name,subs);
 		if( subs.size() > 0 ){
 			//オーバーロードを解決
-			psi=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
-
-			if(!psi) return 0;
-		}
-
-
-		ret_type=psi->ReturnType;
-		*plpRetIndex=psi->u.ReturnIndex;
+			pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
+
+			if(!pSub) return 0;
+		}
+
+
+		ret_type=pSub->ReturnType;
+		*plpRetIndex=pSub->u.ReturnIndex;
 	}
 	else if(idProc==PROC_DLL){
@@ -318,5 +318,5 @@
 
 	//オーバーロード用の関数リストを作成
-	std::vector<SUBINFO *> subs;
+	std::vector<SubInfo *> subs;
 	GetOverloadSubHash(VarName,subs);
 	if(subs.size()==0){
@@ -334,11 +334,11 @@
 
 	//オーバーロードを解決
-	SUBINFO *psi;
-	psi=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
-
-	if(psi){
+	SubInfo *pSub;
+	pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
+
+	if(pSub){
 		if(pRetTypeInfo){
-			pRetTypeInfo->type=psi->ReturnType;
-			pRetTypeInfo->u.lpIndex=psi->u.ReturnIndex;
+			pRetTypeInfo->type=pSub->ReturnType;
+			pRetTypeInfo->u.lpIndex=pSub->u.ReturnIndex;
 		}
 	}
@@ -349,5 +349,5 @@
 //インデクサ（getter）の戻り値を取得
 bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
-	std::vector<SUBINFO *> subs;
+	std::vector<SubInfo *> subs;
 	pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
 	if( subs.size() == 0 ){
@@ -644,5 +644,5 @@
 	return 0;
 }
-SUBINFO *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
+SubInfo *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
 	int i,i2,i3,sw;
 	DWORD dwType;
@@ -761,42 +761,41 @@
 	SubNum++;
 
-	SUBINFO *psi;
-	psi=(SUBINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(SUBINFO));
+	SubInfo *pSub = new SubInfo();
 
 	//クラス名
-	psi->pobj_ParentClass=pobj_c;
+	pSub->pobj_ParentClass=pobj_c;
 
 	//ID
 	static int id_base=0;
-	psi->id=(id_base++);
+	pSub->id=(id_base++);
 
 	//関数名
-	psi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-	lstrcpy(psi->name,temporary);
+	pSub->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
+	lstrcpy(pSub->name,temporary);
 
 	//ソースコードの位置
-	psi->address=NowLine;
-
-	psi->bExport=bExport;
-	psi->bCdecl=bCdecl;
-	psi->bVirtual=bVirtual;
-	if(bExport) psi->bUse=1;
-	else psi->bUse=0;
-	psi->bCompile=0;
-	psi->bSystem=0;
-
-	psi->dwType=dwType;
-
-
-	if(psi->dwType==SUBTYPE_FUNCTION){
+	pSub->address=NowLine;
+
+	pSub->bExport=bExport;
+	pSub->bCdecl=bCdecl;
+	pSub->bVirtual=bVirtual;
+	if(bExport) pSub->bUse=1;
+	else pSub->bUse=0;
+	pSub->bCompile=0;
+	pSub->bSystem=0;
+
+	pSub->dwType=dwType;
+
+
+	if(pSub->dwType==SUBTYPE_FUNCTION){
 		///////////////////
 		// 戻り値を取得
 		///////////////////
 
-		psi->isReturnRef = false;
+		pSub->isReturnRef = false;
 
 		if(pobj_c){
-			if(lstrcmp(psi->name,pobj_c->name)==0||
-				psi->name[0]=='~'){
+			if(lstrcmp(pSub->name,pobj_c->name)==0||
+				pSub->name[0]=='~'){
 				//クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
 				SetError(115,NULL,NowLine);
@@ -814,5 +813,5 @@
 				if( buffer[i2-2] == 1 && buffer[i2-1] == ESC_BYREF ){
 					//参照型
-					psi->isReturnRef = true;
+					pSub->isReturnRef = true;
 				}
 
@@ -827,6 +826,6 @@
 					temporary[i3]=buffer[i2];
 				}
-				psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
-				if(psi->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
+				pSub->ReturnType=GetTypeFixed(temporary,&pSub->u.ReturnIndex);
+				if(pSub->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
 
 				sw_as=1;
@@ -836,19 +835,14 @@
 
 		if(!sw_as){
-			SetError(-104,psi->name,NowLine);
-
-			psi->ReturnType=DEF_DOUBLE;
+			SetError(-104,pSub->name,NowLine);
+
+			pSub->ReturnType=DEF_DOUBLE;
 		}
 	}
 	else{
 		//戻り値なしのSub定義
-		psi->ReturnType=DEF_NON;
-		psi->u.ReturnIndex=-1;
-	}
-
-
-
-	psi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(PARAMETER_INFO)*2);
-	psi->ParmNum=0;
+		pSub->ReturnType=DEF_NON;
+		pSub->u.ReturnIndex=-1;
+	}
 
 	//パラメータ
@@ -860,5 +854,5 @@
 	if(buffer[i]!=')'&&pobj_c){
 		//クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
-		if(psi->name[0]=='~'){
+		if(pSub->name[0]=='~'){
 			SetError(114,NULL,NowLine);
 			i=JumpStringInPare(buffer,i);
@@ -868,18 +862,20 @@
 		if(buffer[i]==')') break;
 
-		psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
-
-		//ByVal
+		//ByRef
+		bool isRef;
 		if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-			psi->pParmInfo[psi->ParmNum].bByVal=1;
+			isRef = false;
 			i+=2;
 		}
 		else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
-			psi->pParmInfo[psi->ParmNum].bByVal=0;
+			isRef = true;
 			i+=2;
 		}
-		else psi->pParmInfo[psi->ParmNum].bByVal=1;
+		else isRef = false;
 
 		//パラメータ名
+		bool isArray = false;
+		int subScripts[MAX_ARRAYDIM];
+		char name[VN_SIZE];
 		sw=0;
 		for(i2=0;;i++,i2++){
@@ -887,5 +883,5 @@
 				if(!sw) sw=1;
 
-				i3=GetStringInPare(temporary+i2,buffer+i);
+				i3=GetStringInPare(name+i2,buffer+i);
 				i2+=i3-1;
 				i+=i3-1;
@@ -895,5 +891,5 @@
 				if(!sw) sw=1;
 
-				i3=GetStringInBracket(temporary+i2,buffer+i);
+				i3=GetStringInBracket(name+i2,buffer+i);
 				i2+=i3-1;
 				i+=i3-1;
@@ -901,36 +897,31 @@
 			}
 			if(!IsVariableChar(buffer[i])){
-				temporary[i2]=0;
+				name[i2]=0;
 				break;
 			}
-			temporary[i2]=buffer[i];
+			name[i2]=buffer[i];
 		}
 		if(sw){
 			//配列パラメータ
-			if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
-			psi->pParmInfo[psi->ParmNum].bArray=1;
-
-			if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
-				(temporary[i2-2]=='['&&temporary[i2-1]==']')){
-				psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
-				psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
-
-				temporary[i2-2]=0;
+			if( isRef == false ) SetError(29,NULL,NowLine);
+			isArray = true;
+
+			if((name[i2-2]=='('&&name[i2-1]==')')||
+				(name[i2-2]=='['&&name[i2-1]==']')){
+				subScripts[0]=LONG_MAX;
+				subScripts[1]=-1;
+
+				name[i2-2]=0;
 			}
 			else{
-				GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
-				lstrcpy(temporary,temp2);
-			}
-
-			i2=lstrlen(temporary);
-		}
-		else{
-			psi->pParmInfo[psi->ParmNum].bArray=0;
-			psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
-		}
-		psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
-		lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
+				GetArrange(name,temp2,subScripts);
+				lstrcpy(name,temp2);
+			}
+
+			i2=lstrlen(name);
+		}
 
 		//型
+		Type type( DEF_NON );
 		if(buffer[i]==1&&buffer[i+1]==ESC_AS){
 			i+=2;
@@ -955,6 +946,5 @@
 			}
 
-			psi->pParmInfo[psi->ParmNum].type=
-				GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
+			Type::StringToType( temporary, type );
 
 			if(temporary[0]=='*'&&
@@ -963,5 +953,5 @@
 				if(buffer[i]!='('){
 					SetError(10,temporary,NowLine);
-					return 0;
+					break;
 				}
 				i3=GetStringInPare(temporary+i2,buffer+i);
@@ -986,26 +976,26 @@
 			}
 
-			if(psi->pParmInfo[psi->ParmNum].type==-1){
+			if( type.IsNull() ){
 				SetError(3,temporary,NowLine);
-				psi->pParmInfo[psi->ParmNum].type=DEF_PTR_VOID;
-			}
-
-			/*未完成（構造体パラメータを値参照として渡してよいものか！？）
-			if(psi->pParmInfo[psi->ParmNum].type==DEF_OBJECT){
-				if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(28,temporary,NowLine);
-			}*/
+				type.SetBasicType( DEF_PTR_VOID );
+			}
 		}
 		else{
-			psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
+			type.SetBasicType( GetTypeFromSimpleName(temporary) );
 			SetError(-103,temporary,NowLine);
 		}
 
-		if(psi->pParmInfo[psi->ParmNum].type==DEF_PTR_PROC){
+		if( type.IsProcPtr() ){
 			//関数ポインタの場合
-			psi->pParmInfo[psi->ParmNum].u.index=AddProcPtrInfo(temporary+3,temporary[2]);
-		}
-
-		//パラメータの数を更新
-		psi->ParmNum++;
+			type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
+		}
+
+		Parameter *pParam = new Parameter( name, type, isRef );
+		if( isArray ){
+			pParam->SetArray( subScripts );
+		}
+
+		//パラメータを追加
+		pSub->params.push_back( pParam );
 
 		if(buffer[i]==','){
@@ -1016,8 +1006,8 @@
 		else{
 			SetError(1,NULL,NowLine);
-			return 0;
-		}
-	}
-	psi->SecondParmNum=psi->ParmNum;
+			break;
+		}
+	}
+	pSub->SecondParmNum = (int)pSub->params.size();
 	i++;
 	if(buffer[i]=='('){
@@ -1026,18 +1016,20 @@
 			if(buffer[i]==')') break;
 
-			psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
-
-			//ByVal
+			//ByRef
+			bool isRef;
 			if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-				psi->pParmInfo[psi->ParmNum].bByVal=1;
+				isRef = false;
 				i+=2;
 			}
 			else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
-				psi->pParmInfo[psi->ParmNum].bByVal=0;
+				isRef = true;
 				i+=2;
 			}
-			else psi->pParmInfo[psi->ParmNum].bByVal=1;
+			else isRef = false;
 
 			//パラメータ名
+			bool isArray = false;
+			int subScripts[MAX_ARRAYDIM];
+			char name[VN_SIZE];
 			sw=0;
 			for(i2=0;;i++,i2++){
@@ -1045,5 +1037,5 @@
 					if(!sw) sw=1;
 
-					i3=GetStringInPare(temporary+i2,buffer+i);
+					i3=GetStringInPare(name+i2,buffer+i);
 					i2+=i3-1;
 					i+=i3-1;
@@ -1053,5 +1045,5 @@
 					if(!sw) sw=1;
 
-					i3=GetStringInBracket(temporary+i2,buffer+i);
+					i3=GetStringInBracket(name+i2,buffer+i);
 					i2+=i3-1;
 					i+=i3-1;
@@ -1059,38 +1051,34 @@
 				}
 				if(!IsVariableChar(buffer[i])){
-					temporary[i2]=0;
+					name[i2]=0;
 					break;
 				}
-				temporary[i2]=buffer[i];
+				name[i2]=buffer[i];
 			}
 			if(sw){
 				//配列パラメータ
-				if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
-				psi->pParmInfo[psi->ParmNum].bArray=1;
-
-				if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
-					(temporary[i2-2]=='['&&temporary[i2-1]==']')){
-					psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
-					psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
-
-					temporary[i2-2]=0;
+				if( isRef == false ) SetError(29,NULL,NowLine);
+				isArray = true;
+
+				if((name[i2-2]=='('&&name[i2-1]==')')||
+					(name[i2-2]=='['&&name[i2-1]==']')){
+					subScripts[0]=LONG_MAX;
+					subScripts[1]=-1;
+
+					name[i2-2]=0;
 				}
 				else{
-					GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
-					lstrcpy(temporary,temp2);
-				}
-
-				i2=lstrlen(temporary);
-			}
-			else{
-				psi->pParmInfo[psi->ParmNum].bArray=0;
-				psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
-			}
-			psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
-			lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
+					GetArrange(name,temp2,subScripts);
+					lstrcpy(name,temp2);
+				}
+
+				i2=lstrlen(name);
+			}
 
 			//型
+			Type type( DEF_NON );
 			if(buffer[i]==1&&buffer[i+1]==ESC_AS){
 				i+=2;
+
 				i2=0;
 				while(buffer[i]=='*'){
@@ -1101,4 +1089,9 @@
 				for(;;i++,i2++){
 					if(!IsVariableChar(buffer[i])){
+						if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
+							temporary[i2++]=buffer[i++];
+							temporary[i2]=buffer[i];
+							continue;
+						}
 						temporary[i2]=0;
 						break;
@@ -1106,14 +1099,57 @@
 					temporary[i2]=buffer[i];
 				}
-				psi->pParmInfo[psi->ParmNum].type=
-					GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
-				if(psi->pParmInfo[psi->ParmNum].type==-1) SetError(3,temporary,NowLine);
+
+				Type::StringToType( temporary, type );
+
+				if(temporary[0]=='*'&&
+					temporary[1]==1&&
+					(temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
+					if(buffer[i]!='('){
+						SetError(10,temporary,NowLine);
+						break;
+					}
+					i3=GetStringInPare(temporary+i2,buffer+i);
+					i+=i3;
+					i2+=i3;
+
+					if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
+						temporary[i2++]=buffer[i++];
+						temporary[i2++]=buffer[i++];
+						for(;;i++,i2++){
+							if(!IsVariableChar(buffer[i])){
+								temporary[i2]=0;
+								break;
+							}
+							temporary[i2]=buffer[i];
+						}
+					}
+				}
+				else{
+					//TypeDefをする前のベース型を取得
+					GetOriginalTypeName(temporary);
+				}
+
+				if( type.IsNull() ){
+					SetError(3,temporary,NowLine);
+					type.SetBasicType( DEF_PTR_VOID );
+				}
 			}
 			else{
-				psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
+				type.SetBasicType( GetTypeFromSimpleName(temporary) );
 				SetError(-103,temporary,NowLine);
 			}
 
-			psi->ParmNum++;
+			if( type.IsProcPtr() ){
+				//関数ポインタの場合
+				type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
+			}
+
+			Parameter *pParam = new Parameter( name, type, isRef );
+			if( isArray ){
+				pParam->SetArray( subScripts );
+			}
+
+			//パラメータを追加
+			pSub->params.push_back( pParam );
 
 			if(buffer[i]==','){
@@ -1124,5 +1160,5 @@
 			else{
 				SetError(1,NULL,NowLine);
-				return 0;
+				break;
 			}
 		}
@@ -1130,43 +1166,28 @@
 	}
 
-	//リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する）
-	psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
-	psi->RealParmNum=0;
+	//リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する場合がある）
 
 	if(pobj_c&&bStatic==0){
-		i = psi->RealParmNum;
-
 		//オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
-		psi->pRealParmInfo[i].name = "_System_LocalThis";
-		psi->pRealParmInfo[i].type=DEF_PTR_VOID;
-		psi->pRealParmInfo[i].u.index=-1;
-		psi->pRealParmInfo[i].bByVal=1;
-		psi->pRealParmInfo[i].bArray=0;
-		psi->pRealParmInfo[i].SubScripts[0]=-1;
-
-		psi->RealParmNum++;
-	}
-
-	if(psi->ReturnType==DEF_STRUCT){
-		i = psi->RealParmNum;
-
+		string name = "_System_LocalThis";
+		Type type( DEF_PTR_VOID );
+		pSub->realParams.push_back( new Parameter( name, type ) );
+	}
+
+	if(pSub->ReturnType==DEF_STRUCT){
 		//構造体を戻り値として持つ場合
 		//※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
 
-		if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
-			psi->pRealParmInfo[i].name="_System_ReturnValue";
-		else psi->pRealParmInfo[i].name=psi->name;
-		psi->pRealParmInfo[i].type=DEF_STRUCT;
-		psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
-		psi->pRealParmInfo[i].bByVal=0;
-		psi->pRealParmInfo[i].bArray=0;
-		psi->pRealParmInfo[i].SubScripts[0]=-1;
-		
-		psi->RealParmNum++;
+		string name = pSub->name;
+		if(pSub->name[0]==1&&pSub->name[1]==ESC_OPERATOR){
+			name="_System_ReturnValue";
+		}
+		Type type( DEF_STRUCT, pSub->u.ReturnIndex );
+		pSub->realParams.push_back( new Parameter( name, type, true ) );
 	}
 
 	//パラメータをコピー
-	for( i = 0; i < psi->ParmNum; i++, psi->RealParmNum++ ){
-		psi->pRealParmInfo[psi->RealParmNum]=psi->pParmInfo[i];
+	foreach( Parameter *pParam, pSub->params ){
+		pSub->realParams.push_back( new Parameter( *pParam ) );
 	}
 
@@ -1177,16 +1198,16 @@
 
 	int key;
-	key=hash_default(psi->name);
-
-	extern SUBINFO **ppSubHash;
+	key=hash_default(pSub->name);
+
+	extern SubInfo **ppSubHash;
 	if(ppSubHash[key]){
-		SUBINFO *psi2;
+		SubInfo *psi2;
 		psi2=ppSubHash[key];
 		while(1){
 			if(pobj_c==psi2->pobj_ParentClass){
 				//重複エラーチェックを行う
-				if(lstrcmp(psi2->name,psi->name)==0){
-					if(CompareParameter(psi2->pParmInfo,psi2->ParmNum,psi->pParmInfo,psi->ParmNum)==0){
-						SetError(15,psi->name,NowLine);
+				if(lstrcmp(psi2->name,pSub->name)==0){
+					if( Parameter::Equals( psi2->params, pSub->params ) ){
+						SetError(15,pSub->name,NowLine);
 						return 0;
 					}
@@ -1197,11 +1218,11 @@
 			psi2=psi2->pNextData;
 		}
-		psi2->pNextData=psi;
+		psi2->pNextData=pSub;
 	}
 	else{
-		ppSubHash[key]=psi;
-	}
-
-	return psi;
+		ppSubHash[key]=pSub;
+	}
+
+	return pSub;
 }
 
@@ -1217,7 +1238,7 @@
 
 	//サブルーチン（ユーザー定義）情報を初期化
-	extern SUBINFO **ppSubHash;
+	extern SubInfo **ppSubHash;
 	extern int SubNum;
-	ppSubHash=(SUBINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SUBINFO *));
+	ppSubHash=(SubInfo **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SubInfo *));
 	SubNum=0;
 
@@ -1313,21 +1334,19 @@
 	AddSubData(temporary,0,0,0);
 }
-void Delete_si(SUBINFO *psi){
-	int i2;
-
-	for(i2=0;i2<psi->ParmNum;i2++){
-		HeapDefaultFree(psi->pParmInfo[i2].name);
-	}
-	HeapDefaultFree(psi->pRealParmInfo);
-	if(psi->pParmInfo) HeapDefaultFree(psi->pParmInfo);
-	psi->pRealParmInfo=0;
-	psi->pParmInfo=0;
-
-	if(psi->pNextData) Delete_si(psi->pNextData);
-
-	HeapDefaultFree(psi->name);
-	HeapDefaultFree(psi);
-}
-void DeleteSubInfo(SUBINFO **ppSubHash,char **ppMacroNames,int MacroNum){	//サブルーチン情報のメモリ解放
+void Delete_si(SubInfo *pSub){
+	foreach( Parameter *pParam, pSub->params ){
+		delete pParam;
+	}
+
+	foreach( Parameter *pParam, pSub->realParams ){
+		delete pParam;
+	}
+
+	if(pSub->pNextData) Delete_si(pSub->pNextData);
+
+	HeapDefaultFree(pSub->name);
+	delete pSub;
+}
+void DeleteSubInfo(SubInfo **ppSubHash,char **ppMacroNames,int MacroNum){	//サブルーチン情報のメモリ解放
 	int i;
 	for(i=0;i<MAX_HASH;i++){
Index: BasicCompiler_Common/Type.cpp
===================================================================
--- BasicCompiler_Common/Type.cpp	(revision 71)
+++ BasicCompiler_Common/Type.cpp	(revision 73)
@@ -108,2 +108,113 @@
 	return false;
 }
+
+
+bool Type::Equals( const Type &type ) const
+{
+	if( basicType == type.basicType ){
+		if( NATURAL_TYPE( basicType ) == DEF_OBJECT
+			|| NATURAL_TYPE( basicType ) == DEF_STRUCT ){
+
+				if( index == type.index ){
+					return true;
+				}
+
+		}
+		else{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool Type::IsNull() const{
+  if( basicType == DEF_NON ){
+	  return true;
+  }
+  return false;
+}
+bool Type::IsPointer() const
+{
+	if(PTR_LEVEL( basicType )|| basicType == DEF_PTR_VOID || basicType == DEF_PTR_PROC
+		|| ( basicType & FLAG_PTR ) ){
+			return true;
+	}
+
+	return false;
+}
+bool Type::IsSigned() const
+{
+	switch( basicType ){
+		case DEF_SBYTE:
+		case DEF_INTEGER:
+		case DEF_LONG:
+		case DEF_INT64:
+		case DEF_SINGLE:
+		case DEF_DOUBLE:
+			return true;
+		default:
+			break;
+	}
+	return false;
+}
+bool Type::IsNaturalWhole() const
+{
+	switch( basicType ){
+		case DEF_SBYTE:
+		case DEF_BYTE:
+		case DEF_INTEGER:
+		case DEF_WORD:
+		case DEF_LONG:
+		case DEF_DWORD:
+		case DEF_INT64:
+		case DEF_QWORD:
+			return true;
+		default:
+			break;
+	}
+	return false;
+}
+bool Type::IsWhole() const
+{
+	return (
+		IsNaturalWhole()
+		|| IsPtrType( basicType )
+		|| basicType == DEF_BOOLEAN
+		);
+}
+bool Type::IsReal() const
+{
+	switch( basicType ){
+		case DEF_SINGLE:
+		case DEF_DOUBLE:
+			return true;
+		default:
+			break;
+	}
+	return false;
+}
+bool Type::Is64() const
+{
+	switch( basicType ){
+		case DEF_QWORD:
+		case DEF_INT64:
+			return true;
+		default:
+			break;
+	}
+	return false;
+}
+bool Type::IsProcPtr() const
+{
+	if( basicType == DEF_PTR_PROC ){
+		return true;
+	}
+	return false;
+}
+bool Type::IsStruct() const
+{
+	if( basicType == DEF_STRUCT ){
+		return true;
+	}
+	return false;
+}
Index: BasicCompiler_Common/Type.h
===================================================================
--- BasicCompiler_Common/Type.h	(revision 71)
+++ BasicCompiler_Common/Type.h	(revision 73)
@@ -4,4 +4,8 @@
 
 class Type{
+	static const int basicTypeList[];
+	static const string basicTypeNameList[];
+
+
 	int basicType;
 	union{
@@ -10,9 +14,12 @@
 	};
 
-	static const int basicTypeList[];
-	static const string basicTypeNameList[];
-
 public:
 
+	static bool StringToBasicType( const string &typeName, int &basicType );
+	static bool StringToType( const string &typeName, Type &type );
+
+	Type():
+	  basicType( DEF_NON ),
+	  index( -1 ){}
 	Type( int basicType ):
 	  basicType( basicType ),
@@ -31,6 +38,11 @@
 	  index( type.index ){}
 
-	int BasicType() const
+	int GetBasicType() const
 	{
+#ifdef _DEBUG
+		if( basicType<-10000 ){
+			DebugBreak();
+		}
+#endif
 		return basicType;
 	}
@@ -44,40 +56,38 @@
 	}
 
+	void SetBasicType( int basicType ){
+		this->basicType = basicType;
+	}
+	void SetIndex( LONG_PTR index ){
+		this->index = index;
+	}
+	void SetNull(){
+		SetBasicType( DEF_NON );
+	}
+	void SetType( int basicType, LONG_PTR index ){
+		SetBasicType( basicType );
+		SetIndex( index );
+	}
+	void SetType( int basicType, CClass *pClass ){
+		SetBasicType( basicType );
+		this->pClass = pClass;
+	}
+
 	void PtrLevelUp(){
 		PTR_LEVEL_UP( basicType );
 	}
 
-	bool Equals( const Type &type ) const
-	{
-		if( basicType == type.basicType ){
-			if( NATURAL_TYPE( basicType ) == DEF_OBJECT
-				|| NATURAL_TYPE( basicType ) == DEF_STRUCT ){
+	bool Equals( const Type &type ) const;
 
-					if( index == type.index ){
-						return true;
-					}
+	bool IsNull() const;
+	bool IsPointer() const;
+	bool IsSigned() const;
+	bool IsNaturalWhole() const;
+	bool IsWhole() const;
+	bool IsReal() const;
+	bool Is64() const;
+	bool IsProcPtr() const;
+	bool IsStruct() const;
 
-			}
-			else{
-				return true;
-			}
-		}
-		return false;
-	}
-
-	bool IsPointer() const
-	{
-		if(PTR_LEVEL( basicType )|| basicType == DEF_PTR_VOID || basicType == DEF_PTR_PROC
-			|| ( basicType & FLAG_PTR ) ){
-				return true;
-		}
-
-		return false;
-	}
-
-
-
-	static bool StringToBasicType( const string &typeName, int &basicType );
-	static bool StringToType( const string &typeName, Type &type );
 };
 
Index: BasicCompiler_Common/Variable.cpp
===================================================================
--- BasicCompiler_Common/Variable.cpp	(revision 71)
+++ BasicCompiler_Common/Variable.cpp	(revision 73)
@@ -819,5 +819,5 @@
 
 	char temporary[VN_SIZE];
-	extern SUBINFO *pCompilingSubInfo;
+	extern SubInfo *pCompilingSubInfo;
 	if(pCompilingSubInfo){
 		GetNowStaticVarFullName(VarName,temporary);
@@ -1100,5 +1100,5 @@
 			//初期値の型を判別して自動的に型情報を付加する
 			TYPEINFO BaseType = GetStringTypeInfo();
-			int result = NumOpe_GetType( InitBuf, &BaseType, &pTypeInfo->u.lpIndex );
+			int result = NumOpe_GetType_Old( InitBuf, &BaseType, &pTypeInfo->u.lpIndex );
 
 			//エラーの場合
@@ -1130,5 +1130,5 @@
 
 BOOL GetNowStaticVarFullName(char *VarName,char *FullName){
-	extern SUBINFO *pCompilingSubInfo;
+	extern SubInfo *pCompilingSubInfo;
 	if(!pCompilingSubInfo) return 0;
 
Index: BasicCompiler_Common/calculation.cpp
===================================================================
--- BasicCompiler_Common/calculation.cpp	(revision 71)
+++ BasicCompiler_Common/calculation.cpp	(revision 73)
@@ -1195,28 +1195,4 @@
 	return 0;
 }
-BOOL IsStringSubsituation(CClass *pobj_c){
-	//String受け入れ可能な "=" 演算子をオーバーロードしているかどうかを調べる
-	BOOL bRet=0;
-
-	std::vector<SUBINFO *> subs;
-	pobj_c->EnumMethod( CALC_SUBSITUATION, subs );
-	if( subs.size() == 0 ){
-		bRet=0;
-		goto finish;
-	}
-
-	foreach( SUBINFO *psi, subs ){
-		if(psi->ParmNum==2){
-			TYPEINFO TypeInfo={psi->pParmInfo[1].type,psi->pParmInfo[1].u.index};
-			if(IsStringObjectType( TypeInfo )){
-				bRet=1;
-				goto finish;
-			}
-		}
-	}
-
-finish:
-	return bRet;
-}
 int IsStrCalculation(char *Command){
 	int i,i2,i3,i4,type,PareNum;
@@ -1282,5 +1258,5 @@
 
 					//ユーザー定義関数
-					SUBINFO *psi;
+					SubInfo *psi;
 					psi=GetSubHash(temporary);
 					if(psi){
Index: BasicCompiler_Common/common.h
===================================================================
--- BasicCompiler_Common/common.h	(revision 71)
+++ BasicCompiler_Common/common.h	(revision 73)
@@ -155,4 +155,7 @@
 #include "Parameter.h"
 
+// プロシージャ管理用のクラス
+#include "Procedure.h"
+
 
 
@@ -229,55 +232,4 @@
 };
 
-#define SUBTYPE_SUB			1
-#define SUBTYPE_FUNCTION	2
-#define SUBTYPE_MACRO		3
-struct SUBINFO{
-	DWORD dwType;
-
-	//クラス情報
-	CClass *pobj_ParentClass;
-
-	long id;
-
-	char *name;
-	long address;
-
-	//パラメータ
-	PARAMETER_INFO *pParmInfo;
-	int ParmNum;
-	int SecondParmNum;
-	PARAMETER_INFO *pRealParmInfo;
-	int RealParmNum;
-	int RealSecondParmNum;
-
-	/*
-	//パラメータ
-	Parameters params;
-	int SecondParmNum;
-	Parameters realParams;
-	int RealSecondParmNum;*/
-
-	//戻り値
-	int ReturnType;
-	union{
-		LONG_PTR ReturnIndex;
-		CClass *Return_pobj_c;
-	}u;
-	bool isReturnRef;
-
-	DWORD CompileAddress;
-	DWORD EndOpAddr;
-	VARIABLE *pVar;
-	int VarNum;
-
-	BOOL bExport;
-	BOOL bCdecl;
-	BOOL bVirtual;
-	BOOL bUse;
-	BOOL bCompile;
-	BOOL bSystem;
-
-	SUBINFO *pNextData;
-};
 #define DECLARE_DYNAMIC	1
 #define DECLARE_STATIC	2
@@ -435,7 +387,7 @@
 CONSTINFO *GetConstHash(char *name);
 DECLAREINFO *GetDeclareHash(char *name);
-SUBINFO *GetSubHash(const char *name,BOOL bError=0);
-SUBINFO *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError=0);
-void GetOverloadSubHash( const char *lpszName, std::vector<SUBINFO *> &subs );
+SubInfo *GetSubHash(const char *name,BOOL bError=0);
+SubInfo *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError=0);
+void GetOverloadSubHash( const char *lpszName, std::vector<SubInfo *> &subs );
 
 //Object.cpp
@@ -444,13 +396,13 @@
 
 //Overload.sbp
-SUBINFO *OverloadSolutionWithStrParam(
+SubInfo *OverloadSolutionWithStrParam(
 	const char *name,
-	std::vector<SUBINFO *> &subs,
+	std::vector<SubInfo *> &subs,
 	const char *Parameter,
 	const char *ObjectName,
 	TYPEINFO *pReturnTypeInfo);
-SUBINFO *OverloadSolution(
+SubInfo *OverloadSolution(
 	const char *name,
-	std::vector<SUBINFO *> &subs,
+	std::vector<SubInfo *> &subs,
 	const PARAMETER_INFO *ppi,
 	const int ParmNum,
@@ -464,5 +416,5 @@
 void Debugger_Pause(void);
 ULONG_PTR rva_to_real(DWORD p);
-SUBINFO *GetSubFromObp(ULONG_PTR pos);
+SubInfo *GetSubFromObp(ULONG_PTR pos);
 void ReadOpBuffer();
 void DebugProgram(void);
@@ -561,5 +513,4 @@
 DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
 bool IsStringObjectType(const TYPEINFO &TypeInfo);
-BOOL IsStringSubsituation(CClass *pobj_c);
 int IsStrCalculation(char *Command);
 BYTE GetCalcId(const char *Command,int *pi);
@@ -567,8 +518,9 @@
 					   char *values[255],long calc[255],long stack[255]);
 
-//NumOpe_GetType.cpp
+//NumOpe_GetType_Old.cpp
 int AutoBigCast(int BaseType,int CalcType);
 BOOL CheckCalcType(int idCalc,int *type,int sp);
-int NumOpe_GetType(char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex);
+int NumOpe_GetType_Old( const char *Command, TYPEINFO *pBaseTypeInfo, LONG_PTR *plpIndex );
+bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType );
 
 //Subroutine.cpp
@@ -583,7 +535,7 @@
 bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo);
 BOOL CompareParameter(PARAMETER_INFO *ppi1,int pi_num1,PARAMETER_INFO *ppi2,int pi_num2);
-SUBINFO *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic=0);
+SubInfo *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic=0);
 void GetSubInfo(void);
-void DeleteSubInfo(SUBINFO **ppSubHash,char **ppMacroNames,int MacroNum);
+void DeleteSubInfo(SubInfo **ppSubHash,char **ppMacroNames,int MacroNum);
 void DeleteDeclareInfo(void);
 int AddProcPtrInfo(char *buffer,DWORD dwProcType);
Index: BasicCompiler_Common/hash.cpp
===================================================================
--- BasicCompiler_Common/hash.cpp	(revision 71)
+++ BasicCompiler_Common/hash.cpp	(revision 73)
@@ -53,9 +53,5 @@
 }
 
-void GetOverloadSubHash( const char *lpszName, std::vector<SUBINFO *> &subs ){
-	extern SUBINFO *pSubInfo;
-	extern int SubInfoNum;
-	extern int cp;
-
+void GetOverloadSubHash( const char *lpszName, std::vector<SubInfo *> &subs ){
 	char name[VN_SIZE];
 
@@ -127,6 +123,6 @@
 
 		//格納位置を取得
-		extern SUBINFO **ppSubHash;
-		SUBINFO *psi;
+		extern SubInfo **ppSubHash;
+		SubInfo *psi;
 		psi=ppSubHash[key];
 		while(psi){
@@ -144,6 +140,6 @@
 
 //オーバーロードされていない関数を取得（昔のコンパイラソースコードとの互換性保持）
-SUBINFO *GetSubHash(const char *lpszName,BOOL bError){
-	std::vector<SUBINFO *> subs;
+SubInfo *GetSubHash(const char *lpszName,BOOL bError){
+	std::vector<SubInfo *> subs;
 	GetOverloadSubHash(lpszName,subs);
 
@@ -158,15 +154,15 @@
 	}
 
-	SUBINFO *psi;
+	SubInfo *psi;
 	psi = subs[0];
 
 	return psi;
 }
-SUBINFO *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError){
+SubInfo *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError){
 	char temporary[VN_SIZE];
 	sprintf(temporary,"%s.%s",ObjectName,MethodName);
 
-	std::vector<SUBINFO *> subs;
-	SUBINFO *psi;
+	std::vector<SubInfo *> subs;
+	SubInfo *psi;
 	GetOverloadSubHash(temporary,subs);