Context Navigation

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

Last change on this file since 195 was 193, checked in by dai_9181, 17 years ago

File size: 26.5 KB

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

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

Download in other formats: