Context Navigation

source: dev/trunk/abdev/BasicCompiler64/NumOpe.cpp@ 237

Last change on this file since 237 was 232, checked in by dai_9181, 17 years ago

File size: 31.4 KB

Rev	Line
[206]	1	#include "stdafx.h"
	2
[183]	3	#include <jenga/include/smoothie/Smoothie.h>
	4	#include <jenga/include/smoothie/LexicalAnalysis.h>
	5
	6	#include <Compiler.h>
	7
[3]	8	#include "../BasicCompiler_Common/common.h"
	9	#include "Opcode.h"
	10
[76]	11	void NewStringObject(int reg, const char *str){
[3]	12	///////////////////////////////////////////////////////
	13	// lpszTextを元にStringオブジェクトを生成し、
	14	// オブジェクトポインタをregに格納する
	15	///////////////////////////////////////////////////////
	16
	17
	18	//////////////////////////////////////////////////////
	19	///// レジスタ資源のバックアップ
	20	{ BACKUP_REGISTER_RESOURCE
	21	//////////////////////////////////////////////////////
	22
[76]	23	char parameter = (char )malloc( lstrlen( str ) + 32 );
	24	sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
[64]	25	SetStringQuotes( parameter );
	26
[198]	27	Operator_New( compiler.GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, compiler.GetMeta().GetClasses().GetStringClassPtr() ) );
[3]	28
[64]	29	free( parameter );
[3]	30
[64]	31	//mov reg,rax
[226]	32	compiler.codeGenerator.op_mov_RR( reg, REG_RAX );
[3]	33
	34	/////////////////////////////////////////////
	35	////// レジスタ資源を復元
	36	RESTORE_REGISTER_RESOURCE
	37	}////////////////////////////////////////////
	38	}
	39
	40	void SetUseRegFromRax(int type,int UseReg,int XmmReg){
	41	if(IsRealNumberType(type)){
	42	//実数型
	43	if(XmmReg==REG_XMM4){
	44	if(type==DEF_DOUBLE){
	45	//movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
	46	pobj_sf->push(REG_XMM0,sizeof(double));
	47	}
	48	if(type==DEF_SINGLE){
	49	//movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
	50	pobj_sf->push(REG_XMM0,sizeof(float));
	51	}
	52	}
	53	else{
	54	if(type==DEF_DOUBLE){
	55	//movsd xmm_reg,xmm0
[226]	56	compiler.codeGenerator.op_movsd_RR(XmmReg,REG_XMM0);
[3]	57	}
	58	else if(type==DEF_SINGLE){
	59	//movss xmm_reg,xmm0
[226]	60	compiler.codeGenerator.op_movss_RR(XmmReg,REG_XMM0);
[3]	61	}
	62	}
	63	}
	64	else{
	65	//整数型
	66	if(UseReg==REG_R14){
	67	//mov qword ptr[rsp+offset],rax ※スタックフレームを利用
	68	pobj_sf->push(REG_RAX);
	69	}
	70	else{
	71	//mov reg,rax
[226]	72	compiler.codeGenerator.op_mov_RR(UseReg,REG_RAX);
[3]	73	}
	74	}
	75	}
	76
[75]	77	void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
	78	switch( Type::GetBasicSize( bigBasicType ) ){
	79	case sizeof(_int64):
	80	ExtendTypeTo64(baseBasicType,reg);
	81	break;
	82	case sizeof(long):
	83	ExtendTypeTo32(baseBasicType,reg);
	84	break;
	85	case sizeof(short):
	86	ExtendTypeTo16(baseBasicType,reg);
	87	break;
	88	}
	89	}
	90
[97]	91
	92	bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
	93	int UseReg=pobj_reg->GetNextReg();
	94	int XmmReg=pobj_reg->GetNextXmmReg();
	95
	96	//大きな型への暗黙の変換
	97	int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
	98
	99	if(resultType.GetBasicType()&FLAG_PTR){
	100	//配列ポインタ
	101	resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
	102
	103	SetVarPtrToReg(UseReg,&relativeVar);
	104	}
	105	else if(resultType.IsReal()){
	106	//実数型
	107	if( resultType.IsDouble() )
	108	SetXmmReg_DoubleVariable(&relativeVar,XmmReg);
	109	if( resultType.IsSingle() )
	110	SetXmmReg_SingleVariable(&relativeVar,XmmReg);
	111	}
	112	else if( resultType.IsWhole() \|\| resultType.IsObject()){
	113	//整数型
	114	SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg);
	115	}
	116	else if( resultType.IsStruct() ){
	117	//構造体ポインタをUseRegへ格納（構造体は値型）
	118	SetVarPtrToReg(UseReg,&relativeVar);
	119	}
	120	else{
	121	return false;
	122	}
	123
	124	if( resultType.GetBasicType() != bigType ){
	125	// 大きな型へ変換された場合
	126	// ※レジスタの値をキャストする
	127	ExtendRegToBigType( UseReg, bigType, resultType.GetBasicType() );
	128
	129	resultType.SetBasicType( bigType );
	130	}
	131
	132	return true;
	133	}
	134	bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char termFull, const char termLeft, const char *member ){
	135
	136	int UseReg=pobj_reg->GetNextReg();
	137	int XmmReg=pobj_reg->GetNextXmmReg();
	138
	139
	140	if( GetMemberType( objClass, member, resultType, 0, false ) ){
	141	// メンバが見つかったとき
	142
	143	//オブジェクトポインタをr11にコピー
[226]	144	compiler.codeGenerator.op_mov_RR( REG_R11, UseReg );
[97]	145
	146	RELATIVE_VAR relativeVar;
	147	relativeVar.dwKind=VAR_DIRECTMEM;
	148
	149	if( !_member_offset(
	150	true, //エラー表示あり
	151	false, //読み込み専用
	152	objClass,
	153	member,&relativeVar,resultType,0)){
	154	return false;
	155	}
	156
	157	if( !VarToReg( relativeVar, baseType, resultType ) ){
	158	SetError(11,termFull,cp);
	159	}
	160
	161	return true;
	162	}
	163
	164
	165	///////////////////////////////////////////////////////////////////
	166	// 動的メソッドを検索
	167	///////////////////////////////////////////////////////////////////
[206]	168	vector<const UserProc *> userProcs;
[97]	169
	170	char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
[206]	171	ReferenceKind refType;
[97]	172	lstrcpy( methodName, member );
	173	GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
	174
[135]	175	objClass.GetMethods().Enum( methodName, userProcs );
[97]	176	if(userProcs.size()){
	177	//オーバーロードを解決
[206]	178	const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
[97]	179
	180	if( pUserProc ){
	181
	182	resultType = pUserProc->ReturnType();
	183
	184
	185	//////////////////////////////////////////////////////
	186	///// レジスタ資源のバックアップ
	187	{ BACKUP_REGISTER_RESOURCE
	188	//////////////////////////////////////////////////////
	189
	190	//オブジェクトポインタをスタックに入れておく
	191	//mov qword ptr[rsp+offset],reg ※スタックフレームを利用
	192	pobj_sf->push( UseReg );
	193
	194	if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
	195	//レジスタ資源を復元
	196	RESTORE_REGISTER_RESOURCE
	197
	198	return false;
	199	}
	200
	201	pobj_sf->pop();
	202
	203	/////////////////////
	204	// 戻り値の処理
	205	/////////////////////
	206
	207	//大きな型への暗黙の変換
	208	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
	209
	210	if( resultType.GetBasicType() != bigType ){
	211	// 大きな型へ変換された場合
	212	// ※レジスタの値をキャストする
	213	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
	214
	215	resultType.SetBasicType( bigType );
	216	}
	217
	218	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
	219
	220
	221	/////////////////////////////////////////////
	222	////// レジスタ資源を復元
	223	RESTORE_REGISTER_RESOURCE
	224	}////////////////////////////////////////////
	225
	226	return true;
	227	}
	228	}
	229
	230	return false;
	231	}
[128]	232	bool TermOpe( const char term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
[97]	233	char parameter[VN_SIZE];
	234
	235	// Withを解決
	236	char termFull[VN_SIZE];
	237	if(term[0]=='.'){
	238	GetWithName(termFull);
	239	lstrcat(termFull,term);
	240	}
	241	else lstrcpy(termFull,term);
	242
	243	char termLeft[VN_SIZE];
	244	lstrcpy(termLeft,termFull);
	245
	246	// パース
	247	char member[VN_SIZE];
[206]	248	ReferenceKind refType;
	249	if( SplitMemberName( termFull, termLeft, member, refType ) ){
[97]	250	///////////////////////////////////////////////////////////////////
	251	// オブジェクトとメンバに分解できるとき
	252	// termLeft.member
	253	///////////////////////////////////////////////////////////////////
	254
	255	isLiteral = false;
	256
	257	// オブジェクト側の型を取得
	258	bool isClassName = false;
	259	Type leftType;
[128]	260	if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
[198]	261	if( isClassName == false && compiler.GetMeta().GetBlittableTypes().IsExist( leftType ) ){
[128]	262	// 左側のオブジェクト部分がBlittable型のとき
	263
	264	char temporary[VN_SIZE];
	265	lstrcpy( temporary, termLeft );
	266	sprintf( termLeft, "%s(%s)",
[198]	267	compiler.GetMeta().GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
[128]	268	temporary );
	269	}
	270	}
	271
	272	if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){
[103]	273	goto globalArea;
[97]	274	}
	275
	276	if( isClassName ){
	277	// 静的メンバ/メソッドの場合
	278	goto globalArea;
	279	}
	280
	281	if( !leftType.HasMember() ){
	282	// メンバを持たない型の場合
	283	return false;
	284	}
	285
	286	return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
	287	}
[103]	288	globalArea:
[97]	289
	290	//////////////////////////////////////////////
	291	// クラス名かどうかをチェック（静的メンバ用）
	292	//////////////////////////////////////////////
	293
	294	if( pIsClassName ){
[198]	295	if( compiler.GetMeta().GetClasses().Find( termFull ) ){
[97]	296	*pIsClassName = true;
	297	return true;
	298	}
	299	}
	300
	301
	302	/////////////////////////////////////////////////////////////////
	303	// グローバル属性エリア
	304	/////////////////////////////////////////////////////////////////
	305
	306	int UseReg=pobj_reg->GetNextReg();
	307	int XmmReg=pobj_reg->GetNextXmmReg();
	308
	309
[122]	310	if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
[97]	311	//Thisオブジェクト
[206]	312	resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
[97]	313
	314	SetThisPtrToReg( UseReg );
	315
	316	isLiteral = false;
	317
	318	return true;
	319	}
	320
	321
	322	//////////////////////////////////////
	323	// 関数（DLL、ユーザー定義、組み込み）
	324	//////////////////////////////////////
	325	char procName[VN_SIZE];
	326	char temporary[8192];
	327
	328	int i2=GetCallProcName(termFull,procName);
	329	if(termFull[i2]=='('){
	330	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
	331
	332	void *pInfo;
	333	int idProc=GetProc(procName,(void **)&pInfo);
	334
	335	if(idProc){
	336	//閉じカッコ")"に続く文字がNULLでないとき
	337	if(termFull[i2+1+i4+1]!='\0'){
	338	SetError(42,NULL,cp);
	339	}
	340
	341
	342	//////////////////////////////////////////////////////
	343	///// レジスタ資源のバックアップ
	344	{ BACKUP_REGISTER_RESOURCE
	345	//////////////////////////////////////////////////////
	346
	347
	348	////////////////
	349	// 呼び出し
	350	////////////////
	351
	352	CallProc(idProc,pInfo,procName,parameter,resultType);
	353
	354
	355	/////////////////////
	356	// 戻り値の処理
	357	/////////////////////
	358
	359	//大きな型への暗黙の変換
	360	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
	361
	362	if( resultType.GetBasicType() != bigType ){
	363	// 大きな型へ変換された場合
	364	// ※レジスタの値をキャストする
	365	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
	366
	367	resultType.SetBasicType( bigType );
	368	}
	369
	370	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
	371
	372	/////////////////////////////////////////////
	373	////// レジスタ資源を復元
	374	RESTORE_REGISTER_RESOURCE
	375	}////////////////////////////////////////////
	376
	377	if(resultType.IsStruct()){
	378	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
	379	//※後にfreeする必要あり
	380	// TODO: 解放はGCに任せる
	381	*pbUseHeap = 1;
	382	}
	383
	384	isLiteral = false;
	385
	386	return true;
	387	}
	388
[206]	389	ConstMacro *pConstMacro = compiler.GetMeta().GetGlobalConstMacros().Find( procName );
	390	if( pConstMacro )
	391	{
	392	if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
	393	{
	394	/////////////////////////
	395	// マクロ関数
	396	/////////////////////////
[97]	397
[206]	398	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
	399	if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
[97]	400
[206]	401	//マクロ関数の場合
	402	NumOpe(&UseReg, temporary,Type(),resultType);
	403
	404	if(!IS_LITERAL(resultType.GetIndex())){
	405	//リテラル値ではなかったとき
	406	isLiteral = false;
	407	}
	408
	409	return true;
[97]	410	}
	411	}
	412	}
[122]	413	else if( isProcedureCallOnly ){
	414	// 関数呼び出し以外は受け付けない
	415	return false;
	416	}
[97]	417
	418
	419	////////////////////////////////
	420	// インデクサ（getアクセサ）
	421	////////////////////////////////
	422
	423	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	424	GetArrayElement(termFull,VarName,ArrayElements);
	425	if(ArrayElements[0]){
	426	GetVarType(VarName,resultType,false);
	427	if( resultType.IsObject() ){
	428	CallIndexerGetterProc(UseReg,&resultType.GetClass(),VarName,ArrayElements,resultType);
	429
	430	isLiteral = false;
	431
	432	return true;
	433	}
	434	}
	435
	436
	437	////////////////////////////////
	438	// 変数
	439	////////////////////////////////
	440
	441	RELATIVE_VAR relativeVar;
	442	if(GetVarOffset(
	443	false, //エラー表示なし
	444	false, //読み込み専用
	445	termFull,
	446	&relativeVar,resultType)){
	447	//////////
	448	// 変数
	449	//////////
	450
	451	if( !VarToReg( relativeVar, baseType, resultType ) ){
	452	SetError(11,termFull,cp);
	453	}
	454
	455	isLiteral = false;
	456
	457	return true;
	458	}
	459
	460	/*
	461	////////////////////////////////
	462	// 型名
	463	////////////////////////////////
	464
[198]	465	if( Compiler::StringToType( termFull, resultType ) ){
[97]	466	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
	467	return true;
	468	}*/
	469
	470
	471	/////////////////////////////////
	472	// プロパティ用のメソッド
	473	/////////////////////////////////
	474
	475	//配列要素を排除
	476	GetArrayElement(termFull,VarName,ArrayElements);
	477
	478	if(GetSubHash(VarName,0)){
	479
	480	//////////////////////////////////////////////////////
	481	///// レジスタ資源のバックアップ
	482	{ BACKUP_REGISTER_RESOURCE
	483	//////////////////////////////////////////////////////
	484
	485	CallPropertyMethod(termFull,NULL,resultType);
	486
	487	//大きな型への暗黙の変換
	488	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
	489
	490	if( resultType.GetBasicType() != bigType ){
	491	// 大きな型へ変換された場合
	492	// ※レジスタの値をキャストする
	493	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
	494
	495	resultType.SetBasicType( bigType );
	496	}
	497
	498	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
	499
	500	/////////////////////////////////////////////
	501	////// レジスタ資源を復元
	502	RESTORE_REGISTER_RESOURCE
	503	}////////////////////////////////////////////
	504
	505	if(resultType.IsStruct()){
	506	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
	507	//※後にfreeする必要あり
	508	// TODO: 解放はGCに任せる
	509	*pbUseHeap = 1;
	510	}
	511
	512	isLiteral = false;
	513
	514	return true;
	515	}
	516
	517
	518	return false;
	519	}
	520
[75]	521	bool NumOpe( int *pReg,
	522	const char *expression,
	523	const Type &baseType,
	524	Type &resultType,
	525	BOOL *pbUseHeap ){
	526
[97]	527	int i,i2,i3;
	528	char temporary[1024],temp2[1024];
[3]	529
[75]	530	if(expression[0]=='\0'){
[3]	531	SetError(1,NULL,cp);
[75]	532	return false;
[3]	533	}
	534
[75]	535	if(expression[0]==1&& expression[1]==ESC_NEW ){
[3]	536	//New演算子（オブジェクト生成）
[64]	537
[140]	538	if( pobj_BlockReg->check(REG_RAX) ){
	539	SetError();
[75]	540	}
	541
[140]	542	//////////////////////////////////////////////////////
	543	///// レジスタ資源のバックアップ
	544	{ BACKUP_REGISTER_RESOURCE
	545	//////////////////////////////////////////////////////
	546
	547	if( !Operator_New( expression+2, baseType, resultType ) ){
	548	return false;
	549	}
	550
	551	/////////////////////////////////////////////
	552	////// レジスタ資源を復元
	553	RESTORE_REGISTER_RESOURCE
	554	}////////////////////////////////////////////
	555
[64]	556	//mov reg,rax
[226]	557	compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
[64]	558
[75]	559	return true;
[3]	560	}
	561
[93]	562	if( !baseType.IsNull() && expression[0] == '[' ){
	563	// リテラル配列の場合
[3]	564
[93]	565	if( !baseType.IsPointer() ){
	566	SetError(1,NULL,cp);
	567	return false;
	568	}
	569	Type tempBaseType( baseType );
	570	tempBaseType.PtrLevelDown();
	571
	572	char buffer = (char )malloc( lstrlen( expression ) + 1 );
	573	lstrcpy( buffer, expression );
	574	RemoveStringBracket( buffer );
	575
	576	void *binary = malloc( 1 );
	577	int num = 0;
	578
	579	i = 0;
	580	while( buffer[i] ){
	581	i = GetOneParameter( buffer, i, temporary );
	582	if( buffer[i] == ',' ){
	583	i++;
	584	}
	585
	586	Type resultType;
	587	_int64 i64data;
	588	if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
	589	return false;
	590	}
	591	if( !resultType.IsWhole() ){
	592	// TODO: 実数に未対応
	593	SetError();
	594	return false;
	595	}
	596
	597	binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
	598	memcpy( (char )binary + (num tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
	599	num++;
	600	}
	601
[224]	602	i2 = compiler.GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
[93]	603
	604	//mov reg,i2
[226]	605	compiler.codeGenerator.op_mov_RV(sizeof(_int64),*pReg,i2);
[93]	606	obp-=sizeof(long);
	607	pobj_DataTableSchedule->add();
	608	obp+=sizeof(long);
	609
	610	free( buffer );
	611
	612	resultType = baseType;
	613
	614	return true;
	615	}
	616
	617
[3]	618	/////////////////////////////////
	619	// 式要素を逆ポーランド式で取得
	620	/////////////////////////////////
	621
	622	char *values[255];
	623	long calc[255];
	624	long stack[255];
	625	int pnum;
[75]	626	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
[3]	627	for(i=0;i<pnum;i++){
	628	if(values[i]) HeapDefaultFree(values[i]);
	629	}
	630	return 0;
	631	}
	632
	633
	634	BOOL bInitRegSwitch=0;
	635	if(!pobj_reg){
	636	bInitRegSwitch=1;
	637
	638	//作業用レジスタを取得
	639	pobj_reg=new CRegister(*pReg);
	640	}
	641
	642	//エラー時の復旧用
	643	CRegister objReg_Backup;
	644	objReg_Backup=*pobj_reg;
	645
	646
	647
	648	////////////////////////////////
	649	// 演算部分のコード生成を開始
	650	////////////////////////////////
	651
	652	BOOL bError;
	653	bError=0;
	654
	655	//リテラル値のみの計算かどうかを判別するためのフラグ
	656	BOOL bLiteralCalculation=1;
	657
	658	//リテラル演算の場合を考慮した演算前のバッファ位置
	659	int BeforeObp;
	660	BeforeObp=obp;
	661
	662	//リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
	663	//※64ビットの掛け算、除算などで特殊関数が呼ばれるため
	664	int Before_ProcAddrScheduleNum;
	665	Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
	666
	667	//リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
	668	int Before_DataTableScheduleNum;
	669	Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
	670
	671	//リテラル演算の場合を考慮した演算前の再配置スケジュール
	672	CReloc *pobj_BackReloc;
	673	pobj_BackReloc=new CReloc();
	674	pobj_BackReloc->copy(pobj_Reloc);
	675
	676	//リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
	677	int Before_StackFrameScheduleNum;
	678	Before_StackFrameScheduleNum=pobj_sf->num;
	679
	680	double dbl;
	681	int sp;
[75]	682	int type_stack[255];
[3]	683	LONG_PTR index_stack[255];
[79]	684	bool isNothing_stack[255];
[3]	685	BOOL bUseHeap[255];
	686	_int64 i64data;
	687	int UseReg,XmmReg;
	688	BOOL bXmm;
	689	for(i=0,sp=0;i<pnum;i++){
	690	int idCalc;
	691	idCalc=calc[i]%100;
	692
	693	if(idCalc){
[75]	694	if(type_stack[sp-2]==DEF_OBJECT){
[79]	695	if( idCalc == CALC_AS
	696	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
	697	&& index_stack[sp-1] == index_stack[sp-2]
	698	\|\| isNothing_stack[sp-2] ){
	699	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
[3]	700	}
[94]	701	else if( idCalc == CALC_AS
	702	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
	703	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
	704	)){
	705	// ダウンキャストを許可する
	706	}
[131]	707	else if( idCalc == CALC_AS
	708	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST ) && ((CClass *)index_stack[sp-1])->IsInterface()
	709	){
	710	// インターフェイスへのキャスト
	711	// TODO: 実装
	712	CastToInterface( pobj_reg->GetLockingReg(), REG_R15, (CClass )index_stack[sp-2], (CClass )index_stack[sp-1] );
	713	}
[79]	714	else{
	715	//オーバーロードされたオペレータを呼び出す
	716	i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
	717	if(i2==0){
	718	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
	719	else GetCalcName(idCalc,temp2);
	720	sprintf(temporary,"Operator %s",temp2);
	721	SetError(27,temporary,cp);
	722	goto error;
	723	}
	724	else if(i2==-1) goto error;
[3]	725
[79]	726	continue;
	727	}
[3]	728	}
	729
[75]	730	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
[3]	731	}
	732
	733	switch(idCalc){
	734	//数値
	735	case 0:
	736	index_stack[sp]=-1;
[79]	737	isNothing_stack[sp] = false;
[3]	738	bUseHeap[sp]=0;
	739
	740	UseReg=pobj_reg->GetNextReg();
	741	XmmReg=pobj_reg->GetNextXmmReg();
	742
	743	bXmm=0;
	744
	745	char *term;
	746	term=values[i];
	747
[97]	748	if( calc[i+1]%100 == CALC_AS ){
	749	// As演算子の右辺値
	750	//型名
[198]	751	if( Compiler::StringToType( term, resultType ) ){
[97]	752	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
	753	}
	754	else{
	755	SetError(3, term, cp );
	756	goto error;
	757	}
	758
	759	type_stack[sp] = resultType.GetBasicType();
	760	index_stack[sp] = resultType.GetIndex();
	761	sp++;
	762
	763	break;
	764	}
	765
[3]	766	if(term[0]=='\"'){
	767	//リテラル文字列
	768	if(!RemoveStringQuotes(term)){
	769	SetError(43,NULL,cp);
	770	goto error;
	771	}
	772	i3=lstrlen(term);
	773	StrLiteral:
[76]	774
[97]	775	if( baseType.IsObject() \|\| baseType.IsNull() ){
	776	//要求タイプがオブジェクト、または未定のとき
[3]	777
[97]	778	//String型オブジェクトを生成
	779	NewStringObject(UseReg,term);
[3]	780
[97]	781	type_stack[sp]=DEF_OBJECT;
[198]	782	index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
[97]	783	bLiteralCalculation=0;
[3]	784
[97]	785	if(bXmm) pobj_reg->LockXmmReg();
	786	else pobj_reg->LockReg();
[3]	787
[97]	788	sp++;
	789	break;
[3]	790	}
	791
[75]	792	type_stack[sp]=typeOfPtrChar;
[3]	793	bLiteralCalculation=0;
	794
[224]	795	i2 = compiler.GetDataTable().AddString( term, i3 );
[3]	796
	797	//mov reg,i2
[226]	798	compiler.codeGenerator.op_mov_RV(sizeof(_int64),UseReg,i2);
[3]	799	obp-=sizeof(long);
	800	pobj_DataTableSchedule->add();
	801	obp+=sizeof(long);
	802
	803	if(UseReg==REG_R14){
	804	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	805	pobj_sf->push(REG_R14);
	806	}
	807	}
	808	else if((term[0]=='e'\|\|term[0]=='E')&&
	809	(term[1]=='x'\|\|term[1]=='X')&&
	810	term[2]=='\"'){
	811	//拡張版リテラル文字列（エスケープシーケンス可能）
	812	if(!RemoveStringQuotes(term+2)){
	813	SetError(43,NULL,cp);
	814	goto error;
	815	}
	816	i3=FormatString_EscapeSequence(term+2);
	817	term+=2;
	818
	819	goto StrLiteral;
	820	}
	821	else if(IsVariableTopChar(term[0])\|\|
	822	term[0]=='*'\|\|
	823	(term[0]=='.'&&IsVariableTopChar(term[1]))){
	824	//////////////////
	825	// 何らかの識別子
	826
[97]	827	bool isLiteral;
	828	if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
	829	if(resultType.IsNull()){
	830	//戻り値が存在しないとき
	831	for(i2=0;;i2++){
	832	if(term[i2]=='('\|\|term[i2]=='\0'){
	833	term[i2]=0;
	834	break;
[49]	835	}
	836	}
[97]	837	SetError(38,term,cp);
[3]	838
[97]	839	goto error;
	840	}
[3]	841
[97]	842	type_stack[sp] = resultType.GetBasicType();
	843	index_stack[sp] = resultType.GetIndex();
[3]	844
[97]	845	if( !isLiteral ){
	846	bLiteralCalculation=0;
	847	}
[3]	848
[97]	849	if( resultType.GetBasicType() & FLAG_CAST ){
	850	// 型名のみ
	851	SetError();
	852	}
	853	else{
	854	if( resultType.IsReal() == false && UseReg==REG_R14 ){
	855	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	856	pobj_sf->push(REG_R14);
	857	}
	858	if( resultType.IsReal() && XmmReg==REG_XMM4 ){
	859	if(resultType.IsDouble()){
	860	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	861	pobj_sf->push(REG_XMM4,sizeof(double));
[3]	862	}
[97]	863	if(resultType.IsSingle()){
	864	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	865	pobj_sf->push(REG_XMM4,sizeof(float));
[75]	866	}
[3]	867	}
	868
[97]	869	if( resultType.IsReal() ){
	870	pobj_reg->LockXmmReg();
[3]	871	}
[97]	872	else{
	873	pobj_reg->LockReg();
	874	}
[3]	875	}
	876
[97]	877	sp++;
	878	break;
[3]	879	}
	880
	881
[67]	882	// Nothing
	883	if( lstrcmp( term, "Nothing" ) == 0 ){
[79]	884	isNothing_stack[sp] = true;
	885
[75]	886	type_stack[sp] = DEF_OBJECT;
	887	if( baseType.IsObject() ){
	888	index_stack[sp] = baseType.GetIndex();
[67]	889	}
	890	else{
[198]	891	index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
[67]	892	}
	893
	894	bLiteralCalculation = 0;
	895
	896	//xor reg,reg
[226]	897	compiler.codeGenerator.op_zero_reg( UseReg );
[67]	898
	899	if(UseReg==REG_R14){
	900	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	901	pobj_sf->push(REG_R14);
	902	}
	903
	904	pobj_reg->LockReg();
	905	sp++;
	906	break;
	907	}
	908
	909
[3]	910	//////////////
	911	// 定数の場合
	912	//////////////
	913
[206]	914	i3 = compiler.GetMeta().GetGlobalConsts().GetBasicType(term);
[9]	915	if(i3){
[206]	916	if( compiler.GetMeta().GetGlobalConsts().IsStringPtr( term ) ){
[103]	917	//リテラル文字列
	918
[206]	919	double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
[103]	920	memcpy(&i64data,&dbl,sizeof(double));
	921
	922	//バイト数
	923	i3=lstrlen((char *)i64data);
	924
	925	memcpy(term,(char *)i64data,i3);
	926	term[i3]=0;
	927	goto StrLiteral;
	928	}
	929
[75]	930	type_stack[sp] = i3;
[3]	931	if(IsRealNumberType(i3)){
	932	//実数
[206]	933	double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
[3]	934	memcpy(&i64data,&dbl,sizeof(double));
	935	goto Literal;
	936	}
	937	else if(IsWholeNumberType(i3)){
	938	//整数
[206]	939	i64data = compiler.GetMeta().GetGlobalConsts().GetWholeData(term);
[3]	940	goto Literal;
	941	}
[9]	942	/*else if(i3==DEF_STRING){
[3]	943	//リテラル文字列
	944
	945	//バイト数
	946	i3=(int)dbl;
	947
	948	memcpy(term,temporary,i3);
	949	goto StrLiteral;
[9]	950	}*/
[3]	951	else{
	952	SetError(1,NULL,0);
	953	goto error;
	954	}
	955	}
	956
	957
	958	//該当する識別子が見当たらないときはエラー扱いにする
	959	bError=1;
	960	SetError(3,term,cp);
[75]	961	type_stack[sp]=DEF_DOUBLE;
[3]	962	}
	963	else{
	964	//リテラル値
[75]	965	type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
[3]	966	Literal:
[75]	967	if(type_stack[sp]==DEF_DOUBLE){
[3]	968	//64ビット浮動小数型
	969	bXmm=1;
	970
	971	if(XmmReg==REG_XMM4){
	972	//mov r14,i64data
[232]	973	compiler.codeGenerator.op_mov_RV64(REG_R14,i64data);
[3]	974
	975
	976	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	977	pobj_sf->push(REG_R14);
	978	}
	979	else{
[224]	980	i3 = compiler.GetDataTable().Add( i64data );
[3]	981
	982	//movlpd xmm_reg,qword ptr[data table offset]
	983	OpBuffer[obp++]=(char)0x66;
	984	OpBuffer[obp++]=(char)0x0F;
	985	OpBuffer[obp++]=(char)0x12;
	986	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	987	OpBuffer[obp++]=(char)0x25;
	988	((long )(OpBuffer+obp))=i3;
	989	pobj_DataTableSchedule->add();
	990	obp+=sizeof(long);
	991	}
	992	}
[75]	993	else if(type_stack[sp]==DEF_SINGLE){
[3]	994	//32ビット浮動小数型
	995	bXmm=1;
	996
	997	float flt;
	998	int i32data;
	999	memcpy(&dbl,&i64data,sizeof(double));
	1000	flt=(float)dbl;
	1001	memcpy(&i32data,&flt,sizeof(long));
	1002
	1003	if(XmmReg==REG_XMM4){
[97]	1004	SetError(); // TODO: 未実装
[3]	1005	//push term
[226]	1006	//compiler.codeGenerator.op_push_value(i32data);
[3]	1007	}
	1008	else{
[224]	1009	i3=compiler.GetDataTable().Add( i32data );
[3]	1010
	1011	//movss xmm_reg,dword ptr[data table offset]
	1012	OpBuffer[obp++]=(char)0xF3;
	1013	OpBuffer[obp++]=(char)0x0F;
	1014	OpBuffer[obp++]=(char)0x10;
	1015	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	1016	OpBuffer[obp++]=(char)0x25;
	1017	((long )(OpBuffer+obp))=i3;
	1018	pobj_DataTableSchedule->add();
	1019	obp+=sizeof(long);
	1020	}
	1021	}
	1022	else{
	1023	//整数
	1024
	1025	index_stack[sp]=GetLiteralIndex(i64data);
	1026
	1027	//mov reg,i64data
[232]	1028	compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
[3]	1029
	1030	if(UseReg==REG_R14){
	1031	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	1032	pobj_sf->push(REG_R14);
	1033	}
	1034	}
	1035	}
	1036
	1037	if(bXmm) pobj_reg->LockXmmReg();
	1038	else pobj_reg->LockReg();
	1039
	1040	sp++;
	1041	break;
	1042
	1043	//論理演算子
	1044	case CALC_XOR:
	1045	case CALC_OR:
	1046	case CALC_AND:
[75]	1047	if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1048	break;
	1049	case CALC_NOT:
	1050	//value[sp-1]=Not value[sp-1]
	1051	//NOT演算子
[75]	1052	if(!Calc_Not(type_stack,sp)) goto error;
[3]	1053	break;
	1054
	1055	//比較演算子
	1056	case CALC_PE: //value[sp-2] <= value[sp-1]
	1057	case CALC_QE: //value[sp-2] >= value[sp-1]
	1058	case CALC_P: //value[sp-2] < value[sp-1]
	1059	case CALC_Q: //value[sp-2] > value[sp-1]
	1060	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
	1061	case CALC_EQUAL: //value[sp-2] = value[sp-1]
[75]	1062	if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1063	break;
	1064
	1065	//ビットシフト
	1066	case CALC_SHL: //value[sp-2] << value[sp-1]
	1067	case CALC_SHR: //value[sp-2] >> value[sp-1]
[75]	1068	if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
[3]	1069	break;
	1070
	1071	//算術演算
	1072	case CALC_ADDITION:
	1073	case CALC_SUBTRACTION:
	1074	case CALC_PRODUCT:
[75]	1075	if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1076	break;
	1077	case CALC_MOD:
	1078	//value[sp-2]%=value[sp-1]
	1079	//剰余演算
[75]	1080	if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
[3]	1081	break;
	1082	case CALC_QUOTIENT:
	1083	//value[sp-2]/=value[sp-1];
	1084	//除算
[75]	1085	if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
[3]	1086	break;
	1087	case CALC_INTQUOTIENT:
	1088	//value[sp-2]/=value[sp-1]
	1089	//整数除算
[75]	1090	if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
[3]	1091	break;
	1092	case CALC_MINUSMARK:
	1093	//value[sp-1]=-value[sp-1]
	1094	//符号反転
[75]	1095	if(!Calc_MinusMark(type_stack,sp)) goto error;
[3]	1096	break;
	1097	case CALC_POWER:
	1098	//べき乗演算（浮動小数点演算のみ）
[75]	1099	if(!Calc_Power(type_stack,&sp)) goto error;
[3]	1100	break;
	1101	case CALC_AS:
	1102	//キャスト
[75]	1103	if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
[3]	1104	break;
[41]	1105	case CALC_BYVAL:
	1106	//ポインタ型→参照型
[75]	1107	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
[41]	1108	//ポインタ型ではないとき
	1109	SetError( 3, NULL, cp );
	1110	goto error;
	1111	}
[3]	1112
[75]	1113	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
[41]	1114
	1115	break;
	1116
[3]	1117	default:
	1118	SetError(300,NULL,cp);
[41]	1119	goto error;
[3]	1120	}
	1121	}
	1122
	1123	if(bError) goto error;
	1124
	1125	if(sp!=1){
	1126	SetError(1,NULL,cp);
	1127	goto error;
	1128	}
	1129
	1130	if(bLiteralCalculation){
	1131	//右辺値が数値の定数式の場合
[75]	1132	Type resultType;
	1133	StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
[3]	1134
	1135	obp=BeforeObp;
	1136	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
	1137	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
	1138	pobj_Reloc->copy(pobj_BackReloc);
	1139	pobj_sf->num=Before_StackFrameScheduleNum;
	1140	*pobj_reg=objReg_Backup;
	1141
[75]	1142	if(resultType.IsReal()){
	1143	if(baseType.IsReal()) resultType=baseType;
[3]	1144
	1145	XmmReg=pobj_reg->LockXmmReg();
	1146
[75]	1147	if(resultType.IsDouble()){
[224]	1148	i3 = compiler.GetDataTable().Add( i64data );
[3]	1149
	1150	//movlpd xmm_reg,qword ptr[data table offset]
	1151	OpBuffer[obp++]=(char)0x66;
	1152	OpBuffer[obp++]=(char)0x0F;
	1153	OpBuffer[obp++]=(char)0x12;
	1154	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	1155	OpBuffer[obp++]=(char)0x25;
	1156	((long )(OpBuffer+obp))=i3;
	1157	pobj_DataTableSchedule->add();
	1158	obp+=sizeof(long);
	1159	}
[75]	1160	if(resultType.IsSingle()){
[3]	1161	memcpy(&dbl,&i64data,sizeof(_int64));
	1162
	1163	float flt;
	1164	int i32data;
	1165	flt=(float)dbl;
	1166	memcpy(&i32data,&flt,sizeof(long));
	1167
[224]	1168	i3 = compiler.GetDataTable().Add( i32data );
[3]	1169
	1170	//movss xmm_reg,dword ptr[data table offset]
	1171	OpBuffer[obp++]=(char)0xF3;
	1172	OpBuffer[obp++]=(char)0x0F;
	1173	OpBuffer[obp++]=(char)0x10;
	1174	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	1175	OpBuffer[obp++]=(char)0x25;
	1176	((long )(OpBuffer+obp))=i3;
	1177	pobj_DataTableSchedule->add();
	1178	obp+=sizeof(long);
	1179	}
	1180	}
	1181	else{
[75]	1182	if(!resultType.Is64()){
[3]	1183	//整数（符号有り/無し）
	1184
	1185	i3=(long)i64data;
	1186
[75]	1187	if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
	1188	if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
[3]	1189
	1190	i64data=(_int64)i3;
	1191	}
	1192
	1193	UseReg=pobj_reg->LockReg();
	1194
	1195	//mov reg,i64data
[232]	1196	compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
[3]	1197	}
	1198
[75]	1199	type_stack[0]=resultType.GetBasicType();
	1200	index_stack[0]=resultType.GetIndex();
[3]	1201	}
	1202	else{
	1203	//右辺値が数値の定数式ではないとき
	1204	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
	1205	}
	1206
	1207	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
	1208
[75]	1209	if(IsRealNumberType(type_stack[0]))
[3]	1210	*pReg=pobj_reg->UnlockXmmReg();
	1211	else
	1212	*pReg=pobj_reg->UnlockReg();
	1213
	1214
	1215	if(bInitRegSwitch){
	1216	//整合性をチェック（バグ回避）
	1217	pobj_reg->bug_check();
	1218
	1219	//作業レジスタを解放
	1220	delete pobj_reg;
	1221	pobj_reg=0;
	1222	}
	1223
[75]	1224	resultType.SetType( type_stack[0], index_stack[0] );
	1225
	1226	bool isSuccessful = true;
[3]	1227	goto finish;
	1228
	1229
	1230
	1231	//////////////////
	1232	// エラー処理
	1233	//////////////////
	1234
	1235	error:
	1236
	1237	*pobj_reg=objReg_Backup;
	1238
	1239	if(bInitRegSwitch){
	1240	//作業レジスタを解放
	1241	delete pobj_reg;
	1242	pobj_reg=0;
	1243	}
	1244
[75]	1245	isSuccessful = false;
[3]	1246	goto finish;
	1247
	1248
	1249
	1250
	1251	finish:
	1252
	1253	for(i=0;i<pnum;i++){
	1254	if(values[i]) HeapDefaultFree(values[i]);
	1255	}
	1256
	1257	//再配置スケジュールバックアップ情報を解放
	1258	delete pobj_BackReloc;
	1259
[75]	1260	return isSuccessful;
[3]	1261	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: