Context Navigation

source: dev/BasicCompiler32/NumOpe.cpp@ 91

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

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

Download in other formats: