Context Navigation

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

Last change on this file since 306 was 266, checked in by dai_9181, 17 years ago
BasicSourceのシリアライズがうまくいっていない
File size: 30.0 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
[266]	27	Operator_New( compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, compiler.GetObjectModule().meta.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 ) ){
[266]	261	if( isClassName == false && compiler.GetObjectModule().meta.GetBlittableTypes().IsExist( leftType ) ){
[128]	262	// 左側のオブジェクト部分がBlittable型のとき
	263
	264	char temporary[VN_SIZE];
	265	lstrcpy( temporary, termLeft );
	266	sprintf( termLeft, "%s(%s)",
[266]	267	compiler.GetObjectModule().meta.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 ){
[266]	295	if( compiler.GetObjectModule().meta.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
[266]	389	ConstMacro *pConstMacro = compiler.GetObjectModule().meta.GetGlobalConstMacros().Find( procName );
[206]	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
[255]	521	bool _numope( int *pReg,
[75]	522	const char *expression,
	523	const Type &baseType,
	524	Type &resultType,
[255]	525	BOOL *pbUseHeap )
	526	{
[75]	527
[97]	528	int i,i2,i3;
	529	char temporary[1024],temp2[1024];
[3]	530
[75]	531	if(expression[0]=='\0'){
[3]	532	SetError(1,NULL,cp);
[75]	533	return false;
[3]	534	}
	535
[93]	536	if( !baseType.IsNull() && expression[0] == '[' ){
	537	// リテラル配列の場合
[3]	538
[93]	539	if( !baseType.IsPointer() ){
	540	SetError(1,NULL,cp);
	541	return false;
	542	}
	543	Type tempBaseType( baseType );
	544	tempBaseType.PtrLevelDown();
	545
	546	char buffer = (char )malloc( lstrlen( expression ) + 1 );
	547	lstrcpy( buffer, expression );
	548	RemoveStringBracket( buffer );
	549
	550	void *binary = malloc( 1 );
	551	int num = 0;
	552
	553	i = 0;
	554	while( buffer[i] ){
	555	i = GetOneParameter( buffer, i, temporary );
	556	if( buffer[i] == ',' ){
	557	i++;
	558	}
	559
	560	Type resultType;
	561	_int64 i64data;
	562	if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
	563	return false;
	564	}
	565	if( !resultType.IsWhole() ){
	566	// TODO: 実数に未対応
	567	SetError();
	568	return false;
	569	}
	570
	571	binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
	572	memcpy( (char )binary + (num tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
	573	num++;
	574	}
	575
[266]	576	i2 = compiler.GetObjectModule().dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
[93]	577
	578	//mov reg,i2
[242]	579	compiler.codeGenerator.op_mov_RV(sizeof(_int64),*pReg,i2, Schedule::DataTable );
[93]	580
	581	free( buffer );
	582
	583	resultType = baseType;
	584
	585	return true;
	586	}
	587
[254]	588	bool isLiteralCalculation;
	589	if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
	590	{
	591	return false;
	592	}
	593	if( isLiteralCalculation )
	594	{
	595	//右辺値が数値の定数式の場合
	596	_int64 i64data;
	597	StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
[93]	598
[254]	599	if(resultType.IsReal()){
	600	if(baseType.IsReal()) resultType=baseType;
	601
	602	int xmmReg = REG_XMM0;
	603
	604	if(resultType.IsDouble()){
[266]	605	i3 = compiler.GetObjectModule().dataTable.Add( i64data );
[254]	606
	607	//movlpd xmm_reg,qword ptr[data table offset]
	608	compiler.codeGenerator.op_movlpd_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
	609	}
	610	if(resultType.IsSingle()){
	611	double dbl;
	612	memcpy(&dbl,&i64data,sizeof(_int64));
	613
	614	float flt;
	615	int i32data;
	616	flt=(float)dbl;
	617	memcpy(&i32data,&flt,sizeof(long));
	618
[266]	619	i3 = compiler.GetObjectModule().dataTable.Add( i32data );
[254]	620
	621	//movss xmm_reg,dword ptr[data table offset]
	622	compiler.codeGenerator.op_movss_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
	623	}
	624	}
	625	else{
	626	if(!resultType.Is64()){
	627	//整数（符号有り/無し）
	628
	629	i3=(long)i64data;
	630
	631	if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
	632	if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
	633
	634	i64data=(_int64)i3;
	635	}
	636
	637	//mov reg,i64data
	638	compiler.codeGenerator.op_mov_RV64(*pReg,i64data);
	639	}
	640	return true;
	641	}
	642
	643	if(expression[0]==1&& expression[1]==ESC_NEW ){
	644	//New演算子（オブジェクト生成）
	645
	646	if( pobj_BlockReg->check(REG_RAX) ){
	647	SetError();
	648	}
	649
	650	//////////////////////////////////////////////////////
	651	///// レジスタ資源のバックアップ
	652	{ BACKUP_REGISTER_RESOURCE
	653	//////////////////////////////////////////////////////
	654
	655	if( !Operator_New( expression+2, baseType, resultType ) ){
	656	return false;
	657	}
	658
	659	/////////////////////////////////////////////
	660	////// レジスタ資源を復元
	661	RESTORE_REGISTER_RESOURCE
	662	}////////////////////////////////////////////
	663
	664	//mov reg,rax
	665	compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
	666
	667	return true;
	668	}
	669
	670
[3]	671	/////////////////////////////////
	672	// 式要素を逆ポーランド式で取得
	673	/////////////////////////////////
	674
	675	char *values[255];
	676	long calc[255];
	677	long stack[255];
	678	int pnum;
[75]	679	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
[3]	680	for(i=0;i<pnum;i++){
	681	if(values[i]) HeapDefaultFree(values[i]);
	682	}
	683	return 0;
	684	}
	685
	686
	687
	688	////////////////////////////////
	689	// 演算部分のコード生成を開始
	690	////////////////////////////////
	691
	692	BOOL bError;
	693	bError=0;
	694
	695	//リテラル値のみの計算かどうかを判別するためのフラグ
	696	BOOL bLiteralCalculation=1;
	697
	698	double dbl;
	699	int sp;
[75]	700	int type_stack[255];
[3]	701	LONG_PTR index_stack[255];
[79]	702	bool isNothing_stack[255];
[3]	703	BOOL bUseHeap[255];
	704	_int64 i64data;
	705	int UseReg,XmmReg;
	706	BOOL bXmm;
	707	for(i=0,sp=0;i<pnum;i++){
	708	int idCalc;
	709	idCalc=calc[i]%100;
	710
	711	if(idCalc){
[75]	712	if(type_stack[sp-2]==DEF_OBJECT){
[79]	713	if( idCalc == CALC_AS
	714	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
	715	&& index_stack[sp-1] == index_stack[sp-2]
	716	\|\| isNothing_stack[sp-2] ){
	717	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
[3]	718	}
[94]	719	else if( idCalc == CALC_AS
	720	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
	721	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
	722	)){
	723	// ダウンキャストを許可する
	724	}
[131]	725	else if( idCalc == CALC_AS
	726	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST ) && ((CClass *)index_stack[sp-1])->IsInterface()
	727	){
	728	// インターフェイスへのキャスト
	729	// TODO: 実装
	730	CastToInterface( pobj_reg->GetLockingReg(), REG_R15, (CClass )index_stack[sp-2], (CClass )index_stack[sp-1] );
	731	}
[79]	732	else{
	733	//オーバーロードされたオペレータを呼び出す
	734	i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
	735	if(i2==0){
	736	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
	737	else GetCalcName(idCalc,temp2);
	738	sprintf(temporary,"Operator %s",temp2);
	739	SetError(27,temporary,cp);
	740	goto error;
	741	}
	742	else if(i2==-1) goto error;
[3]	743
[79]	744	continue;
	745	}
[3]	746	}
	747
[75]	748	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
[3]	749	}
	750
	751	switch(idCalc){
	752	//数値
	753	case 0:
	754	index_stack[sp]=-1;
[79]	755	isNothing_stack[sp] = false;
[3]	756	bUseHeap[sp]=0;
	757
	758	UseReg=pobj_reg->GetNextReg();
	759	XmmReg=pobj_reg->GetNextXmmReg();
	760
	761	bXmm=0;
	762
	763	char *term;
	764	term=values[i];
	765
[97]	766	if( calc[i+1]%100 == CALC_AS ){
	767	// As演算子の右辺値
	768	//型名
[198]	769	if( Compiler::StringToType( term, resultType ) ){
[97]	770	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
	771	}
	772	else{
	773	SetError(3, term, cp );
	774	goto error;
	775	}
	776
	777	type_stack[sp] = resultType.GetBasicType();
	778	index_stack[sp] = resultType.GetIndex();
	779	sp++;
	780
	781	break;
	782	}
	783
[3]	784	if(term[0]=='\"'){
	785	//リテラル文字列
	786	if(!RemoveStringQuotes(term)){
	787	SetError(43,NULL,cp);
	788	goto error;
	789	}
	790	i3=lstrlen(term);
	791	StrLiteral:
[76]	792
[97]	793	if( baseType.IsObject() \|\| baseType.IsNull() ){
	794	//要求タイプがオブジェクト、または未定のとき
[3]	795
[97]	796	//String型オブジェクトを生成
	797	NewStringObject(UseReg,term);
[3]	798
[97]	799	type_stack[sp]=DEF_OBJECT;
[266]	800	index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
[97]	801	bLiteralCalculation=0;
[3]	802
[97]	803	if(bXmm) pobj_reg->LockXmmReg();
	804	else pobj_reg->LockReg();
[3]	805
[97]	806	sp++;
	807	break;
[3]	808	}
	809
[75]	810	type_stack[sp]=typeOfPtrChar;
[3]	811	bLiteralCalculation=0;
	812
[266]	813	i2 = compiler.GetObjectModule().dataTable.AddString( term, i3 );
[3]	814
	815	//mov reg,i2
[242]	816	compiler.codeGenerator.op_mov_RV(sizeof(_int64),UseReg,i2, Schedule::DataTable);
[3]	817
	818	if(UseReg==REG_R14){
	819	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	820	pobj_sf->push(REG_R14);
	821	}
	822	}
	823	else if((term[0]=='e'\|\|term[0]=='E')&&
	824	(term[1]=='x'\|\|term[1]=='X')&&
	825	term[2]=='\"'){
	826	//拡張版リテラル文字列（エスケープシーケンス可能）
	827	if(!RemoveStringQuotes(term+2)){
	828	SetError(43,NULL,cp);
	829	goto error;
	830	}
	831	i3=FormatString_EscapeSequence(term+2);
	832	term+=2;
	833
	834	goto StrLiteral;
	835	}
	836	else if(IsVariableTopChar(term[0])\|\|
	837	term[0]=='*'\|\|
	838	(term[0]=='.'&&IsVariableTopChar(term[1]))){
	839	//////////////////
	840	// 何らかの識別子
	841
[97]	842	bool isLiteral;
	843	if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
	844	if(resultType.IsNull()){
	845	//戻り値が存在しないとき
	846	for(i2=0;;i2++){
	847	if(term[i2]=='('\|\|term[i2]=='\0'){
	848	term[i2]=0;
	849	break;
[49]	850	}
	851	}
[97]	852	SetError(38,term,cp);
[3]	853
[97]	854	goto error;
	855	}
[3]	856
[97]	857	type_stack[sp] = resultType.GetBasicType();
	858	index_stack[sp] = resultType.GetIndex();
[3]	859
[97]	860	if( !isLiteral ){
	861	bLiteralCalculation=0;
	862	}
[3]	863
[97]	864	if( resultType.GetBasicType() & FLAG_CAST ){
	865	// 型名のみ
	866	SetError();
	867	}
	868	else{
	869	if( resultType.IsReal() == false && UseReg==REG_R14 ){
	870	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	871	pobj_sf->push(REG_R14);
	872	}
	873	if( resultType.IsReal() && XmmReg==REG_XMM4 ){
	874	if(resultType.IsDouble()){
	875	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	876	pobj_sf->push(REG_XMM4,sizeof(double));
[3]	877	}
[97]	878	if(resultType.IsSingle()){
	879	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	880	pobj_sf->push(REG_XMM4,sizeof(float));
[75]	881	}
[3]	882	}
	883
[97]	884	if( resultType.IsReal() ){
	885	pobj_reg->LockXmmReg();
[3]	886	}
[97]	887	else{
	888	pobj_reg->LockReg();
	889	}
[3]	890	}
	891
[97]	892	sp++;
	893	break;
[3]	894	}
	895
	896
[67]	897	// Nothing
	898	if( lstrcmp( term, "Nothing" ) == 0 ){
[79]	899	isNothing_stack[sp] = true;
	900
[75]	901	type_stack[sp] = DEF_OBJECT;
	902	if( baseType.IsObject() ){
	903	index_stack[sp] = baseType.GetIndex();
[67]	904	}
	905	else{
[266]	906	index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
[67]	907	}
	908
	909	bLiteralCalculation = 0;
	910
	911	//xor reg,reg
[226]	912	compiler.codeGenerator.op_zero_reg( UseReg );
[67]	913
	914	if(UseReg==REG_R14){
	915	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	916	pobj_sf->push(REG_R14);
	917	}
	918
	919	pobj_reg->LockReg();
	920	sp++;
	921	break;
	922	}
	923
	924
[3]	925	//////////////
	926	// 定数の場合
	927	//////////////
	928
[266]	929	i3 = compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(term);
[9]	930	if(i3){
[266]	931	if( compiler.GetObjectModule().meta.GetGlobalConsts().IsStringPtr( term ) ){
[103]	932	//リテラル文字列
	933
[266]	934	double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
[103]	935	memcpy(&i64data,&dbl,sizeof(double));
	936
	937	//バイト数
	938	i3=lstrlen((char *)i64data);
	939
	940	memcpy(term,(char *)i64data,i3);
	941	term[i3]=0;
	942	goto StrLiteral;
	943	}
	944
[75]	945	type_stack[sp] = i3;
[3]	946	if(IsRealNumberType(i3)){
	947	//実数
[266]	948	double dbl = compiler.GetObjectModule().meta.GetGlobalConsts().GetDoubleData(term);
[3]	949	memcpy(&i64data,&dbl,sizeof(double));
	950	goto Literal;
	951	}
	952	else if(IsWholeNumberType(i3)){
	953	//整数
[266]	954	i64data = compiler.GetObjectModule().meta.GetGlobalConsts().GetWholeData(term);
[3]	955	goto Literal;
	956	}
[9]	957	/*else if(i3==DEF_STRING){
[3]	958	//リテラル文字列
	959
	960	//バイト数
	961	i3=(int)dbl;
	962
	963	memcpy(term,temporary,i3);
	964	goto StrLiteral;
[9]	965	}*/
[3]	966	else{
	967	SetError(1,NULL,0);
	968	goto error;
	969	}
	970	}
	971
	972
	973	//該当する識別子が見当たらないときはエラー扱いにする
	974	bError=1;
	975	SetError(3,term,cp);
[75]	976	type_stack[sp]=DEF_DOUBLE;
[3]	977	}
	978	else{
	979	//リテラル値
[75]	980	type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
[3]	981	Literal:
[75]	982	if(type_stack[sp]==DEF_DOUBLE){
[3]	983	//64ビット浮動小数型
	984	bXmm=1;
	985
	986	if(XmmReg==REG_XMM4){
	987	//mov r14,i64data
[232]	988	compiler.codeGenerator.op_mov_RV64(REG_R14,i64data);
[3]	989
	990
	991	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	992	pobj_sf->push(REG_R14);
	993	}
	994	else{
[266]	995	i3 = compiler.GetObjectModule().dataTable.Add( i64data );
[3]	996
	997	//movlpd xmm_reg,qword ptr[data table offset]
[242]	998	compiler.codeGenerator.op_movlpd_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
[3]	999	}
	1000	}
[75]	1001	else if(type_stack[sp]==DEF_SINGLE){
[3]	1002	//32ビット浮動小数型
	1003	bXmm=1;
	1004
	1005	float flt;
	1006	int i32data;
	1007	memcpy(&dbl,&i64data,sizeof(double));
	1008	flt=(float)dbl;
	1009	memcpy(&i32data,&flt,sizeof(long));
	1010
	1011	if(XmmReg==REG_XMM4){
[97]	1012	SetError(); // TODO: 未実装
[3]	1013	//push term
[226]	1014	//compiler.codeGenerator.op_push_value(i32data);
[3]	1015	}
	1016	else{
[266]	1017	i3=compiler.GetObjectModule().dataTable.Add( i32data );
[3]	1018
	1019	//movss xmm_reg,dword ptr[data table offset]
[242]	1020	compiler.codeGenerator.op_movss_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
[3]	1021	}
	1022	}
	1023	else{
	1024	//整数
	1025
	1026	index_stack[sp]=GetLiteralIndex(i64data);
	1027
	1028	//mov reg,i64data
[232]	1029	compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
[3]	1030
	1031	if(UseReg==REG_R14){
	1032	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	1033	pobj_sf->push(REG_R14);
	1034	}
	1035	}
	1036	}
	1037
	1038	if(bXmm) pobj_reg->LockXmmReg();
	1039	else pobj_reg->LockReg();
	1040
	1041	sp++;
	1042	break;
	1043
	1044	//論理演算子
	1045	case CALC_XOR:
	1046	case CALC_OR:
	1047	case CALC_AND:
[75]	1048	if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1049	break;
	1050	case CALC_NOT:
	1051	//value[sp-1]=Not value[sp-1]
	1052	//NOT演算子
[75]	1053	if(!Calc_Not(type_stack,sp)) goto error;
[3]	1054	break;
	1055
	1056	//比較演算子
	1057	case CALC_PE: //value[sp-2] <= value[sp-1]
	1058	case CALC_QE: //value[sp-2] >= value[sp-1]
	1059	case CALC_P: //value[sp-2] < value[sp-1]
	1060	case CALC_Q: //value[sp-2] > value[sp-1]
	1061	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
	1062	case CALC_EQUAL: //value[sp-2] = value[sp-1]
[75]	1063	if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1064	break;
	1065
	1066	//ビットシフト
	1067	case CALC_SHL: //value[sp-2] << value[sp-1]
	1068	case CALC_SHR: //value[sp-2] >> value[sp-1]
[75]	1069	if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
[3]	1070	break;
	1071
	1072	//算術演算
	1073	case CALC_ADDITION:
	1074	case CALC_SUBTRACTION:
	1075	case CALC_PRODUCT:
[75]	1076	if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	1077	break;
	1078	case CALC_MOD:
	1079	//value[sp-2]%=value[sp-1]
	1080	//剰余演算
[75]	1081	if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
[3]	1082	break;
	1083	case CALC_QUOTIENT:
	1084	//value[sp-2]/=value[sp-1];
	1085	//除算
[75]	1086	if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
[3]	1087	break;
	1088	case CALC_INTQUOTIENT:
	1089	//value[sp-2]/=value[sp-1]
	1090	//整数除算
[75]	1091	if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
[3]	1092	break;
	1093	case CALC_MINUSMARK:
	1094	//value[sp-1]=-value[sp-1]
	1095	//符号反転
[75]	1096	if(!Calc_MinusMark(type_stack,sp)) goto error;
[3]	1097	break;
	1098	case CALC_POWER:
	1099	//べき乗演算（浮動小数点演算のみ）
[75]	1100	if(!Calc_Power(type_stack,&sp)) goto error;
[3]	1101	break;
	1102	case CALC_AS:
	1103	//キャスト
[75]	1104	if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
[3]	1105	break;
[41]	1106	case CALC_BYVAL:
	1107	//ポインタ型→参照型
[75]	1108	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
[41]	1109	//ポインタ型ではないとき
	1110	SetError( 3, NULL, cp );
	1111	goto error;
	1112	}
[3]	1113
[75]	1114	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
[41]	1115
	1116	break;
	1117
[3]	1118	default:
	1119	SetError(300,NULL,cp);
[41]	1120	goto error;
[3]	1121	}
	1122	}
	1123
	1124	if(bError) goto error;
	1125
	1126	if(sp!=1){
	1127	SetError(1,NULL,cp);
	1128	goto error;
	1129	}
	1130
	1131	if(bLiteralCalculation){
[255]	1132	SetError();
[3]	1133	}
	1134	else{
	1135	//右辺値が数値の定数式ではないとき
	1136	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
	1137	}
	1138
	1139	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
	1140
[75]	1141	if(IsRealNumberType(type_stack[0]))
[3]	1142	*pReg=pobj_reg->UnlockXmmReg();
	1143	else
	1144	*pReg=pobj_reg->UnlockReg();
	1145
	1146
[75]	1147	resultType.SetType( type_stack[0], index_stack[0] );
	1148
	1149	bool isSuccessful = true;
[3]	1150	goto finish;
	1151
	1152
	1153
	1154	//////////////////
	1155	// エラー処理
	1156	//////////////////
	1157
	1158	error:
	1159
[75]	1160	isSuccessful = false;
[3]	1161	goto finish;
	1162
	1163
	1164
	1165
	1166	finish:
	1167
	1168	for(i=0;i<pnum;i++){
	1169	if(values[i]) HeapDefaultFree(values[i]);
	1170	}
	1171
[75]	1172	return isSuccessful;
[3]	1173	}
[255]	1174
	1175	bool NumOpe( int *pReg,
	1176	const char *expression,
	1177	const Type &baseType,
	1178	Type &resultType,
	1179	BOOL *pbUseHeap )
	1180	{
	1181	BOOL bInitRegSwitch=0;
	1182	if(!pobj_reg){
	1183	bInitRegSwitch=1;
	1184
	1185	//作業用レジスタを取得
	1186	pobj_reg=new CRegister(*pReg);
	1187	}
	1188
	1189	//エラー時の復旧用
	1190	CRegister objReg_Backup;
	1191	objReg_Backup=*pobj_reg;
	1192
	1193	*pReg = pobj_reg->GetNextReg();
	1194
	1195
	1196	bool result = _numope( pReg, expression, baseType, resultType, pbUseHeap );
	1197
	1198
	1199	if( !result )
	1200	{
	1201	*pobj_reg=objReg_Backup;
	1202	}
	1203
	1204	if(bInitRegSwitch){
	1205	//整合性をチェック（バグ回避）
	1206	if( result )
	1207	{
	1208	pobj_reg->bug_check();
	1209	}
	1210
	1211	//作業レジスタを解放
	1212	delete pobj_reg;
	1213	pobj_reg=0;
	1214	}
	1215
	1216	return result;
	1217	}

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

Download in other formats: