source: dev/BasicCompiler32/NumOpe.cpp@ 74

Last change on this file since 74 was 69, checked in by dai_9181, 18 years ago

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