Context Navigation

source: dev/BasicCompiler32/NumOpe.cpp@ 65

Last change on this file since 65 was 64, checked in by dai_9181, 18 years ago
すべてのオブジェクトを参照型に切り替えた。
File size: 17.5 KB

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

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

Download in other formats: