Context Navigation

source: dev/trunk/abdev/BasicCompiler32/NumOpe.cpp@ 228

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

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

Download in other formats: