Context Navigation

source: dev/BasicCompiler32/NumOpe.cpp@ 76

Last change on this file since 76 was 76, checked in by dai_9181, 17 years ago
TYPEINFO→Typeへのリファクタリングを実施。32bitが未完成。
File size: 18.2 KB

Rev	Line
[3]	1	#include "../BasicCompiler_Common/common.h"
	2	#include "Opcode.h"
	3
	4	void PushReturnValue(int type){
	5	//関数の戻り値をスタックへプッシュする
	6	//※この処理内では、esi、ediは使用不可
	7
[64]	8	if(type==DEF_OBJECT \|\| type==DEF_STRUCT){
[3]	9	//push eax
	10	op_push(REG_EAX);
	11	}
	12	else if(type==DEF_DOUBLE){
	13	//sub esp,8
	14	op_sub_esp(8);
	15
	16	//fstp qword ptr[esp]
	17	OpBuffer[obp++]=(char)0xDD;
	18	OpBuffer[obp++]=(char)0x1C;
	19	OpBuffer[obp++]=(char)0x24;
	20	}
	21	else if(type==DEF_SINGLE){
	22	//sub esp,4
	23	op_sub_esp(4);
	24
	25	//fstp dword ptr[esp]
	26	OpBuffer[obp++]=(char)0xD9;
	27	OpBuffer[obp++]=(char)0x1C;
	28	OpBuffer[obp++]=(char)0x24;
	29	}
	30	else if(type==DEF_INT64\|\|type==DEF_QWORD){
	31	//push edx
	32	op_push(REG_EDX);
	33
	34	//push eax
	35	op_push(REG_EAX);
	36	}
	37	else if(type==DEF_LONG){
	38	//push eax
	39	op_push(REG_EAX);
	40	}
[55]	41	else if(type==DEF_INTEGER \|\| (isUnicode&&type==DEF_CHAR)){
[3]	42	//movsx ebx,ax
	43	OpBuffer[obp++]=(char)0x0F;
	44	OpBuffer[obp++]=(char)0xBF;
	45	OpBuffer[obp++]=(char)0xD8;
	46
	47	//push ebx
	48	op_push(REG_EBX);
	49	}
[55]	50	else if(type==DEF_SBYTE \|\| (isUnicode==false&&type==DEF_CHAR)){
[3]	51	//movsx ebx,al
	52	OpBuffer[obp++]=(char)0x0F;
	53	OpBuffer[obp++]=(char)0xBE;
	54	OpBuffer[obp++]=(char)0xD8;
	55
	56	//push ebx
	57	op_push(REG_EBX);
	58	}
[36]	59	else if(type==DEF_DWORD\|\|type==DEF_WORD\|\|type==DEF_BYTE\|\|type==DEF_BOOLEAN\|\|
[3]	60	IsPtrType(type)){
	61	//push eax
	62	op_push(REG_EAX);
	63	}
[64]	64	else{
	65	SetError();
[3]	66	}
	67	}
	68
[76]	69	void NewStringObject( const char *str ){
[3]	70	///////////////////////////////////////////////////////
	71	// lpszTextを元にStringオブジェクトを生成し、
[64]	72	// オブジェクトポインタをregに格納する
[3]	73	///////////////////////////////////////////////////////
	74
[76]	75	char parameter = (char )malloc( lstrlen( str ) + 32 );
	76	sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
[64]	77	SetStringQuotes( parameter );
	78
[3]	79	extern CClass *pobj_StringClass;
[76]	80	Operator_New( pobj_StringClass, "", parameter, Type( DEF_OBJECT, pobj_StringClass ) );
[3]	81
[64]	82	free( parameter );
[3]	83	}
	84
	85
[76]	86	bool NumOpe( const char *expression,
	87	const Type &baseType,
	88	Type &resultType,
	89	BOOL *pbUseHeap ){
	90
[3]	91	int i,i2,i3,i4;
[76]	92	char temporary[1024],temp2[1024],temp3[1024];
[3]	93
[76]	94	if(expression[0]=='\0'){
[3]	95	SetError(1,NULL,cp);
[76]	96	return false;
[3]	97	}
	98
[76]	99	if(expression[0]==1&& expression[1]==ESC_NEW ){
[3]	100	//New演算子（オブジェクト生成）
[64]	101
[76]	102	if( !Operator_New( expression+2, baseType, resultType ) ){
	103	return false;
	104	}
	105
	106	return true;
[3]	107	}
	108
	109
	110	/////////////////////////////////
	111	// 式要素を逆ポーランド式で取得
	112	/////////////////////////////////
	113
	114	char *values[255];
	115	long calc[255];
	116	long stack[255];
	117	int pnum;
[76]	118	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
[3]	119	for(i=0;i<pnum;i++){
	120	if(values[i]) HeapDefaultFree(values[i]);
	121	}
[76]	122	return false;
[3]	123	}
	124
	125
	126	BOOL bError;
	127	bError=0;
	128
	129	//リテラル値のみの計算かどうかを判別するためのフラグ
	130	BOOL bLiteralCalculation=1;
	131
	132	//リテラル演算の場合を考慮した演算前のバッファ位置
	133	int BeforeObp;
	134	BeforeObp=obp;
	135
	136	//リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
	137	//※64ビットの掛け算、除算などで特殊関数が呼ばれるため
	138	int Before_ProcAddrScheduleNum;
	139	Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
	140
	141	//リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
	142	int Before_DataTableScheduleNum;
	143	Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
	144
	145	//リテラル演算の場合を考慮した演算前の再配置スケジュール
	146	CReloc *pobj_BackReloc;
	147	pobj_BackReloc=new CReloc();
	148	pobj_BackReloc->copy(pobj_Reloc);
	149
	150	double dbl;
	151	int sp;
[76]	152	int type_stack[255];
[3]	153	LONG_PTR index_stack[255];
	154	BOOL bUseHeap[255];
	155	_int64 i64data;
	156	for(i=0,sp=0;i<pnum;i++){
	157	int idCalc;
	158	idCalc=calc[i]%100;
	159
	160	if(idCalc){
[76]	161	if(type_stack[sp-2]==DEF_OBJECT){
[3]	162	//オーバーロードされたオペレータを呼び出す
[76]	163	i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
[3]	164	if(i2==0){
	165	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
	166	else GetCalcName(idCalc,temp2);
	167	sprintf(temporary,"Operator %s",temp2);
	168	SetError(27,temporary,cp);
	169	goto error;
	170	}
	171	else if(i2==-1) goto error;
	172
	173	continue;
	174	}
	175
[76]	176	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
[3]	177	}
	178
	179	switch(idCalc){
	180	//数値
	181	case 0:
	182	index_stack[sp]=-1;
	183	bUseHeap[sp]=0;
	184
	185	char *term;
	186	term=values[i];
	187
	188	if(term[0]=='\"'){
	189	//リテラル文字列
	190	if(!RemoveStringQuotes(term)){
	191	SetError(43,NULL,cp);
	192	goto error;
	193	}
	194	i3=lstrlen(term);
	195	StrLiteral:
	196
[76]	197	if( baseType.IsObject() ){
	198	if( baseType.IsStringObject() ){
	199	//要求タイプがStringのとき
[3]	200
	201	//String型オブジェクトを生成
	202	NewStringObject(term);
	203
	204	extern CClass *pobj_StringClass;
[76]	205	type_stack[sp]=DEF_OBJECT;
[3]	206	index_stack[sp]=(LONG_PTR)pobj_StringClass;
	207	bLiteralCalculation=0;
	208
	209	sp++;
	210	break;
	211	}
	212	}
	213
	214
[76]	215	type_stack[sp]=typeOfPtrChar;
[3]	216	bLiteralCalculation=0;
	217
[56]	218	i2=dataTable.AddString(term,i3);
[3]	219
	220	//push DataSize
	221	OpBuffer[obp++]=(char)0x68;
	222	((long )(OpBuffer+obp))=i2;
	223	pobj_DataTableSchedule->add();
	224	obp+=sizeof(long);
	225	}
	226	else if((term[0]=='e'\|\|term[0]=='E')&&
	227	(term[1]=='x'\|\|term[1]=='X')&&
	228	term[2]=='\"'){
	229	//拡張版リテラル文字列（エスケープシーケンス可能）
	230	if(!RemoveStringQuotes(term+2)){
	231	SetError(43,NULL,cp);
	232	goto error;
	233	}
	234	i3=FormatString_EscapeSequence(term+2);
	235	term+=2;
	236
	237	goto StrLiteral;
	238	}
	239	else if(IsVariableTopChar(term[0])\|\|
	240	term[0]=='*'\|\|
	241	(term[0]=='.'&&IsVariableTopChar(term[1]))){
	242	//////////////////
	243	// 何らかの識別子
	244
	245	//////////////////////////////////////
	246	// 関数（DLL、ユーザー定義、組み込み）
	247	//////////////////////////////////////
	248
	249	i2=GetCallProcName(term,temporary);
	250	if(term[i2]=='('){
	251	i4=GetStringInPare_RemovePare(temp2,term+i2+1);
	252
	253	void *pInfo;
[76]	254	int idProc=GetProc(temporary,(void **)&pInfo);
[3]	255
[76]	256	Type resultType;
[3]	257	if(idProc){
[49]	258	//閉じカッコ")"に続く文字がNULLでないとき
	259	if(term[i2+1+i4+1]!='\0'){
	260	if( term[i2+1+i4+1] == '.'
	261	\|\| term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
	262	goto NonProc;
	263	}
	264	else{
	265	SetError(42,NULL,cp);
	266	}
	267	}
[3]	268
	269	////////////////
	270	// 呼び出し
	271	////////////////
	272
[76]	273	CallProc(idProc,pInfo,temporary,temp2,resultType);
	274	if(resultType.IsNull()){
[3]	275	//戻り値が存在しないとき
	276	for(i2=2;;i2++){
	277	if(term[i2]=='('\|\|term[i2]=='\0'){
	278	term[i2]=0;
	279	break;
	280	}
	281	}
	282	SetError(38,term,cp);
	283
	284	goto error;
	285	}
	286
	287
	288	/////////////////////
	289	// 戻り値の処理
	290	/////////////////////
	291
	292	//大きな型への暗黙の変換
[76]	293	type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
	294	index_stack[sp] = resultType.GetIndex();
[3]	295	bLiteralCalculation=0;
	296
	297	//スタックへプッシュ
[76]	298	PushReturnValue( resultType.GetBasicType() );
[3]	299
[76]	300	if( Is64Type(type_stack[sp])
	301	&& resultType.IsWhole()
	302	&& resultType.GetBasicSize() <= sizeof(long) ){
	303	//必要に応じて64ビット拡張
	304	ExtendStackTo64( resultType.GetBasicType() );
[3]	305	}
	306
[76]	307	if( resultType.IsStruct() ){
[64]	308	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
[3]	309	//※後にfreeする必要あり
	310	bUseHeap[sp]=1;
	311	}
	312
	313	sp++;
	314	break;
	315	}
	316	else if(GetConstCalcBuffer(temporary,temp2,temp3)){
	317	/////////////////////////
	318	// マクロ関数
	319	/////////////////////////
	320
	321	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
	322	if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
	323
	324	//マクロ関数の場合
[76]	325	NumOpe(temp3,Type(),resultType);
[3]	326
[76]	327	if(!IS_LITERAL(resultType.GetIndex())){
[3]	328	//リテラル値ではなかったとき
	329	bLiteralCalculation=0;
	330	}
	331
[76]	332	type_stack[sp] = resultType.GetBasicType();
	333	index_stack[sp] = resultType.GetIndex();
	334
[3]	335	sp++;
	336	break;
	337	}
	338	}
[49]	339	NonProc:
[3]	340
	341
[76]	342	//インデクサ（getアクセサ）
[3]	343	char variable[VN_SIZE],array_element[VN_SIZE];
	344	GetArrayElement(term,variable,array_element);
	345	if(array_element[0]){
[76]	346	Type resultType;
	347	GetVarType(variable,resultType,0);
	348	if( resultType.IsObject() ){
	349	CallIndexerGetterProc(&resultType.GetClass(),variable,array_element,resultType);
	350	type_stack[sp]=resultType.GetBasicType();
	351	index_stack[sp]=resultType.GetIndex();
[3]	352	bLiteralCalculation=0;
	353
	354	//push eax
	355	op_push(REG_EAX);
	356
	357	sp++;
	358	break;
	359	}
	360	}
	361
	362
[67]	363	// Nothing
	364	if( lstrcmp( term, "Nothing" ) == 0 ){
[76]	365	type_stack[sp] = DEF_OBJECT;
	366	if( baseType.IsObject() ){
	367	index_stack[sp] = baseType.GetIndex();
[67]	368	}
	369	else{
	370	index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClass();
	371	}
[3]	372
[67]	373	bLiteralCalculation = 0;
	374
	375	//push 0
	376	op_push_V( 0 );
	377
	378	sp++;
	379	break;
	380	}
	381
	382
[76]	383	if( (string)term=="value"){
	384	int test=0;
	385	}
[67]	386
[76]	387
[3]	388	RELATIVE_VAR RelativeVar;
[76]	389	Type varType;
[11]	390	if(GetVarOffset(
	391	false, //エラー表示あり
	392	false, //読み込み専用
[76]	393	term,
	394	&RelativeVar,varType)){
[3]	395	//////////
	396	// 変数
	397	//////////
	398
	399	//大きな型への暗黙の変換
[76]	400	type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
	401	index_stack[sp] = varType.GetIndex();
[3]	402	bLiteralCalculation=0;
	403
[76]	404	if(varType.GetBasicType()&FLAG_PTR){
[3]	405	//配列ポインタ
[76]	406	type_stack[sp]=GetPtrType(varType.GetBasicType()^FLAG_PTR);
[3]	407
	408	SetVarPtrToEax(&RelativeVar);
	409
	410	//push eax
	411	op_push(REG_EAX);
	412	}
[76]	413	else if( varType.IsStruct() ){
	414	//構造体ポインタをeaxへ格納（構造体は値型）
	415	SetVarPtrToEax(&RelativeVar);
	416
	417	//push eax
	418	op_push(REG_EAX);
	419	}
	420	else if( varType.GetBasicSize() == sizeof(_int64) ){
[3]	421	//64ビット型
	422	PushDoubleVariable(&RelativeVar);
	423	}
[76]	424	else if( varType.GetBasicSize() == sizeof(long) ){
[3]	425	//32ビット型
	426	PushLongVariable(&RelativeVar);
	427	}
[76]	428	else if( varType.IsInteger() ){
[3]	429	PushIntegerVariable(&RelativeVar);
	430	}
[76]	431	else if( varType.IsWord() ){
[3]	432	PushWordVariable(&RelativeVar);
	433	}
[76]	434	else if( varType.IsSByte() ){
[3]	435	PushCharVariable(&RelativeVar);
	436	}
[76]	437	else if( varType.IsByte() \|\| varType.IsBoolean() ){
[3]	438	PushByteVariable(&RelativeVar);
	439	}
[64]	440	else SetError(11,term,cp);
[3]	441
[76]	442	if( Is64Type(type_stack[sp])
	443	&& varType.IsWhole()
	444	&& varType.GetBasicSize()<=sizeof(long)){
[3]	445	//必要に応じて64ビット拡張
[76]	446	ExtendStackTo64( varType.GetBasicType() );
[3]	447	}
	448
	449	sp++;
	450	break;
	451	}
	452
	453
	454	//////////////
	455	// 定数の場合
	456	//////////////
	457
[8]	458	i3 = CDBConst::obj.GetType(term);
	459	if(i3){
[76]	460	type_stack[sp]=i3;
[3]	461	if(IsRealNumberType(i3)){
	462	//実数
[8]	463	double dbl = CDBConst::obj.GetDoubleData(term);
[3]	464	memcpy(&i64data,&dbl,sizeof(double));
	465	goto Literal;
	466	}
	467	else if(IsWholeNumberType(i3)){
	468	//整数
[8]	469	i64data = CDBConst::obj.GetWholeData(term);
[3]	470	goto Literal;
	471	}
[8]	472	/*else if(i3==DEF_STRING){
[3]	473	//リテラル文字列
	474
	475	//バイト数
	476	i3=(int)dbl;
	477
	478	memcpy(term,temporary,i3);
	479	goto StrLiteral;
[8]	480	}*/
[3]	481	else{
	482	SetError(300,NULL,cp);
	483	goto error;
	484	}
	485	}
	486
	487
	488	//////////////
	489	// 型名の場合
	490	//////////////
	491
	492	LONG_PTR lp;
	493	i3=GetTypeFixed(term,&lp);
	494	if(i3!=-1){
[76]	495	type_stack[sp]=i3\|FLAG_CAST;
[3]	496	index_stack[sp]=lp;
	497	sp++;
	498	break;
	499	}
	500
	501
	502
	503	/////////////////////////////////
	504	// プロパティ用のメソッド
	505	/////////////////////////////////
	506
	507	//配列要素を排除
	508	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	509	GetArrayElement(term,VarName,ArrayElements);
	510
	511	if(GetSubHash(VarName,0)){
[76]	512	Type resultType;
	513	CallPropertyMethod(term,NULL,resultType);
[3]	514
	515	//大きな型への暗黙の変換
[76]	516	type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
	517	index_stack[sp]=resultType.GetIndex();
[3]	518	bLiteralCalculation=0;
	519
	520	//スタックへプッシュ
[76]	521	PushReturnValue( resultType.GetBasicType() );
[3]	522
[76]	523	if(type_stack[sp]==DEF_STRUCT){
[64]	524	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
[3]	525	//※後にfreeする必要あり
	526	bUseHeap[sp]=1;
	527	}
	528
	529	sp++;
	530	break;
	531	}
	532
	533
	534
	535	//該当する識別子が見当たらないときはエラー扱いにする
	536	bError=1;
	537	SetError(3,term,cp);
[76]	538	type_stack[sp]=DEF_DOUBLE;
[3]	539	}
	540	else{
	541	//リテラル値
[76]	542	type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
[3]	543	Literal:
[76]	544	if(type_stack[sp]==DEF_INT64\|\|
	545	type_stack[sp]==DEF_QWORD\|\|
	546	type_stack[sp]==DEF_DOUBLE){
[3]	547	//64ビット（符号有り整数/実数）
	548
	549	//push HILONG(dbl)
[67]	550	op_push_V((long)(long )(((char *)(&i64data))+4));
[3]	551
	552	//push LOLONG(dbl)
[67]	553	op_push_V((long )(&i64data));
[3]	554	}
[76]	555	else if(type_stack[sp]==DEF_SINGLE){
[3]	556	//single実数
	557
	558	float flt;
	559	memcpy(&dbl,&i64data,sizeof(double));
	560	flt=(float)dbl;
	561	memcpy(&i3,&flt,sizeof(long));
	562
	563	//push term
[67]	564	op_push_V(i3);
[3]	565	}
	566	else{
	567	//その他
	568
	569	//push term
[67]	570	op_push_V((long)i64data);
[3]	571
	572	if((long)i64data==0) index_stack[sp]=LITERAL_NULL;
	573	}
	574
	575
	576	//リテラル値の種類
[76]	577	if(Is64Type(type_stack[sp])==0&&IsRealNumberType(type_stack[sp])==0){
[3]	578	//整数（符号有り/無し）
	579
	580	index_stack[sp]=GetLiteralIndex(i64data);
	581	}
	582	}
	583	sp++;
	584	break;
	585
	586	//論理演算子
	587	case CALC_XOR:
	588	//value[sp-2] xor= value[sp-1]
	589	//xor演算
[76]	590	if(!Calc_Xor(type_stack,index_stack,&sp)) goto error;
[3]	591	break;
	592	case CALC_OR:
	593	//value[sp-2] or= value[sp-1]
	594	//or演算
[76]	595	if(!Calc_Or(type_stack,index_stack,&sp)) goto error;
[3]	596	break;
	597	case CALC_AND:
	598	//value[sp-2] and= value[sp-1]
	599	//and演算
[76]	600	if(!Calc_And(type_stack,index_stack,&sp)) goto error;
[3]	601	break;
	602	case CALC_NOT:
	603	//value[sp-1]=Not value[sp-1]
	604	//NOT演算子
[76]	605	if(!Calc_Not(type_stack,sp)) goto error;
[3]	606	break;
	607
	608	//比較演算子
	609	case CALC_PE:
	610	//value[sp-2]<=value[sp-1]
[76]	611	if(!Calc_Relation_PE(type_stack,index_stack,&sp)) goto error;
[3]	612	break;
	613	case CALC_QE:
	614	//value[sp-2]>=value[sp-1]
[76]	615	if(!Calc_Relation_QE(type_stack,index_stack,&sp)) goto error;
[3]	616	break;
	617	case CALC_P:
	618	//value[sp-2]<value[sp-1]
[76]	619	if(!Calc_Relation_P(type_stack,index_stack,&sp)) goto error;
[3]	620	break;
	621	case CALC_Q:
	622	//value[sp-2]>value[sp-1]
[76]	623	if(!Calc_Relation_Q(type_stack,index_stack,&sp)) goto error;
[3]	624	break;
	625	case CALC_NOTEQUAL:
	626	//value[sp-2]<>value[sp-1]
[76]	627	if(!Calc_Relation_NotEqual(type_stack,&sp)) goto error;
[3]	628	break;
	629	case CALC_EQUAL:
	630	//value[sp-2]=value[sp-1]
[76]	631	if(!Calc_Relation_Equal(type_stack,&sp)) goto error;
[3]	632	break;
	633
	634	//ビットシフト
	635	case CALC_SHL:
	636	//value[sp-2]=value[sp-2]<<value[sp-1]
[76]	637	if(!Calc_SHL(type_stack,&sp)) goto error;
[3]	638	break;
	639	case CALC_SHR:
	640	//value[sp-2]=value[sp-2]>>value[sp-1]
[76]	641	if(!Calc_SHR(type_stack,&sp)) goto error;
[3]	642	break;
	643
	644	//算術演算
	645	case CALC_ADDITION:
	646	case CALC_SUBTRACTION:
	647	case CALC_PRODUCT:
[76]	648	if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
[3]	649	break;
	650
	651	case CALC_MOD:
	652	//value[sp-2]%=value[sp-1]
	653	//剰余演算
[76]	654	if(!Calc_Mod(type_stack,&sp)) goto error;
[3]	655	break;
	656	case CALC_QUOTIENT:
	657	//value[sp-2]/=value[sp-1];
	658	//除算
[76]	659	if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
[3]	660	break;
	661	case CALC_INTQUOTIENT:
	662	//value[sp-2]/=value[sp-1]
	663	//整数除算
[76]	664	if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
[3]	665	break;
	666	case CALC_MINUSMARK:
	667	//value[sp-1]=-value[sp-1]
	668	//符号反転
[76]	669	if(!Calc_MinusMark(type_stack,sp)) goto error;
[3]	670	index_stack[sp-1]=-1;
	671	break;
	672	case CALC_POWER:
	673	//べき乗演算（浮動小数点演算のみ）
[76]	674	if(!Calc_Power(type_stack,&sp)) goto error;
[3]	675	break;
	676	case CALC_AS:
	677	//キャスト
[76]	678	if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
[3]	679	break;
	680
[41]	681	case CALC_BYVAL:
	682	//ポインタ型→参照型
[76]	683	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
[41]	684	//ポインタ型ではないとき
	685	SetError( 3, NULL, cp );
	686	goto error;
	687	}
	688
[76]	689	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
[41]	690
	691	break;
	692
[3]	693	default:
	694	SetError(300,NULL,cp);
[41]	695	goto error;
[3]	696	}
	697	}
	698
	699	if(bError) goto error;
	700
	701	if(sp!=1){
	702	SetError(1,NULL,cp);
	703	goto error;
	704	}
	705
	706	if(bLiteralCalculation){
	707	//右辺値が数値の定数式の場合
[76]	708	Type resultType;
	709	StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
[3]	710
	711	obp=BeforeObp;
	712	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
	713	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
	714	pobj_Reloc->copy(pobj_BackReloc);
	715
[76]	716	if( resultType.GetBasicSize() == sizeof(_int64) ){
[3]	717	//64ビット（符号有り整数/実数）
	718
	719	//push HILONG(i64data)
[67]	720	op_push_V((long)(long )(((char *)(&i64data))+4));
[3]	721
	722	//push LOLONG(i64data)
[67]	723	op_push_V((long )(&i64data));
[3]	724	}
[76]	725	else if( resultType.IsSingle() ){
[3]	726	//single実数
	727
	728	memcpy(&dbl,&i64data,sizeof(_int64));
	729
	730	float flt;
	731	flt=(float)dbl;
	732	memcpy(&i3,&flt,sizeof(long));
	733
	734	//push flt
[67]	735	op_push_V(i3);
[3]	736	}
	737	else{
	738	//整数（符号有り/無し）
	739
	740	i3=(long)i64data;
	741
[76]	742	if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
	743	if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
[3]	744
	745	//push term
[67]	746	op_push_V(i3);
[3]	747	}
	748
[76]	749	type_stack[0]=resultType.GetBasicType();
	750	index_stack[0]=resultType.GetIndex();
[3]	751	}
	752	else{
	753	//右辺値が数値の定数式ではないとき
	754	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
	755	}
	756
	757	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
	758
[76]	759	resultType.SetType( type_stack[0], index_stack[0] );
	760
	761	bool isSuccessful = true;
[3]	762	goto finish;
	763
	764
	765	error:
[76]	766	isSuccessful = false;
[3]	767	goto finish;
	768
	769
	770	finish:
	771
	772	for(i=0;i<pnum;i++){
	773	if(values[i]) HeapDefaultFree(values[i]);
	774	}
	775
	776	//再配置スケジュールバックアップ情報を解放
	777	delete pobj_BackReloc;
	778
[76]	779	return isSuccessful;
[3]	780	}

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

Download in other formats: