source: dev/BasicCompiler_Common/Subroutine.cpp@ 38

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

戻り値に基本型を持つインデクサ（Getter）が正常に呼び出せないバグを修正。
File size: 31.3 KB
RevLine 
[4]1#include "../BasicCompiler_Common/common.h"
2
3#ifdef _AMD64_
4#include "../BasicCompiler64/opcode.h"
5#else
[5]6#include "../BasicCompiler32/opcode.h"
[4]7#endif
8
9//コンパイル中の関数情報
10SUBINFO *pCompilingSubInfo;
11
12int GetCallProcName(char *buffer,char *name){
13 int i2,i3,IsStr=0;
14
15 for(i2=0;;i2++){
16 if(buffer[i2]=='\"') IsStr^=1;
17 if(IsDBCSLeadByte(buffer[i2])){
18 name[i2]=buffer[i2];
19 i2++;
20 name[i2]=buffer[i2];
21 continue;
22 }
23 if(buffer[i2]=='['&&IsStr==0){
24 i3=GetStringInBracket(name+i2,buffer+i2);
25 i2+=i3-1;
26 continue;
27 }
28 if(buffer[i2]=='('&&IsStr==0){
29 name[i2]=0;
30 break;
31 }
32 if(buffer[i2]=='='&&IsStr==0){
33 name[i2]=0;
34 break;
35 }
36
37 name[i2]=buffer[i2];
38 if(buffer[i2]=='\0') break;
39 }
40 return i2;
41}
42
43int GetProc(char *name,void **ppInfo){
44
45 //ユーザー定義関数
46 *ppInfo=(void *)GetSubHash(name);
47 if(*ppInfo) return PROC_DEFAULT;
48
49 //DLL関数
50 *ppInfo=(void *)GetDeclareHash(name);
51 if(*ppInfo) return PROC_DLL;
52
53 //コンパイラ埋め込み型
54 *ppInfo=(void *)(_int64)GetFunctionFromName(name);
55 if(*ppInfo) return PROC_BUILTIN;
56
57 //関数ポインタ
58 int type;
59 LONG_PTR lpIndex;
60 type=GetVarType(name,&lpIndex,0);
61 if(type==DEF_PTR_PROC) return PROC_PTR;
62
63 return 0;
64}
65
[28]66void SplitObjectName(char *name,char *ObjectName,int *pRefType){
[4]67 int i4;
68 for(i4=lstrlen(name)-1;i4>=0;i4--){
69 if(name[i4]=='.'||(name[i4]==1&&name[i4+1]==ESC_PSMEM))
70 break;
71 }
72 if(i4==-1) ObjectName[0]=0;
73 else{
74 //参照タイプを判別
75 if(name[i4]=='.') *pRefType=DEF_OBJECT;
76 else *pRefType=DEF_PTR_OBJECT;
77
78 if(i4==0) GetWithName(ObjectName);
79 else{
80 memcpy(ObjectName,name,i4);
81 ObjectName[i4]=0;
82 }
83 }
84}
[28]85bool SplitMemberName( const char *desc, char *object, char *member ){
86 int i;
87 for(i=lstrlen(desc)-1;i>=0;i--){
88 if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM))
89 break;
90 }
91 if(i==-1) return false;
92 else{
93 if(desc[i]=='.')
94 lstrcpy(member,desc+i+1);
95 else
96 lstrcpy(member,desc+i+2);
97
98 if( object ){
99 lstrcpy( object, desc );
100 object[i]=0;
101 }
102 }
103
104 return true;
105}
[4]106int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
107 int ret_type;
108
109 if(idProc==PROC_DEFAULT){
110 /////////////////////
111 // ユーザー定義関数
112 /////////////////////
113
114 SUBINFO *psi;
115 psi=(SUBINFO *)pInfo;
116
117 //GetSubHash内でエラー提示が行われた場合
118 if(psi==(SUBINFO *)-1) return -1;
119
120
121 //オブジェクト名を取得
122 char ObjectName[VN_SIZE];
123 int RefType;
[28]124 SplitObjectName(name,ObjectName,&RefType);
[4]125
126
127 ////////////////////////
128 // オーバーロードを解決
129 ////////////////////////
130
131 SUBINFO **ppsi;
132 int num;
133 ppsi=GetOverloadSubHash(name,&num);
134 if(num){
135 //オーバーロードを解決
136 psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
137 HeapDefaultFree(ppsi);
138
139 if(!psi) return 0;
140 }
141
142
143 ret_type=psi->ReturnType;
144 *plpRetIndex=psi->u.ReturnIndex;
145 }
146 else if(idProc==PROC_DLL){
147 /////////////////////////
148 // DLL関数
149 /////////////////////////
150 DECLAREINFO *pdi;
151 pdi=(DECLAREINFO *)pInfo;
152
153 ret_type=pdi->ReturnType;
154 *plpRetIndex=pdi->u.ReturnIndex;
155 }
156 else if(idProc==PROC_BUILTIN){
157 /////////////////////////
158 // 組み込み関数
159 /////////////////////////
160 int FuncId;
161 FuncId=(int)(_int64)pInfo;
162
163 ret_type=GetFunctionType(FuncId);
164 *plpRetIndex=-1;
165 }
166 else if(idProc==PROC_PTR){
167 /////////////////
168 // 関数ポインタ
169 /////////////////
170
171 LONG_PTR lpIndex;
172 GetVarType(name,&lpIndex,0);
173
174 extern PROCPTRINFO *pProcPtrInfo;
175 ret_type=pProcPtrInfo[lpIndex].ReturnType;
176 *plpRetIndex=pProcPtrInfo[lpIndex].u.ReturnIndex;
177 }
178
179 return ret_type;
180}
181BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
182 //プロパティ用のメソッドを呼び出す
183
184 //配列要素を取得
185 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
186 GetArrayElement(variable,VarName,ArrayElements);
187
188 //オブジェクト名を取得
189 char ObjectName[VN_SIZE];
190 int RefType;
[28]191 SplitObjectName(VarName,ObjectName,&RefType);
[4]192
193 //オーバーロード用の関数リストを作成
194 SUBINFO **ppsi;
195 int num;
196 ppsi=GetOverloadSubHash(VarName,&num);
197 if(num==0){
198 return 0;
199 }
200
201 //パラメータを整備
202 char *Parameter;
203 Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
204 lstrcpy(Parameter,ArrayElements);
205 if(RightSide){
206 if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
207 lstrcat(Parameter,RightSide);
208 }
209
210 //オーバーロードを解決
211 SUBINFO *psi;
212 psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
213 HeapDefaultFree(ppsi);
214
215 if(psi){
216 if(pRetTypeInfo){
217 pRetTypeInfo->type=psi->ReturnType;
218 pRetTypeInfo->u.lpIndex=psi->u.ReturnIndex;
219 }
220 }
221
222 return 1;
223}
224
[38]225//インデクサ（getter）の戻り値を取得
226bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
227 SUBINFO **ppsi;
228 int num;
229 ppsi=pobj_Class->GetOperatorSubInfo(CALC_ARRAY_GET,num);
230 if(num==0){
231 HeapDefaultFree(ppsi);
232
233 return false;
234 }
235
236 RetTypeInfo.type = ppsi[0]->ReturnType;
237 RetTypeInfo.u.lpIndex = ppsi[0]->u.ReturnIndex;
238
239 HeapDefaultFree(ppsi);
240
241 return true;
242}
243
244
[4]245void AddDeclareData(char *buffer,int NowLine){
246 extern HANDLE hHeap;
247 int i,i2,i3,i4,sw,IsFunction;
248 char temporary[VN_SIZE];
249
250 i=0;
251
252 DWORD dwType;
253 BOOL bCdecl=0;
254
255 //Static/Dynamic
256 if(buffer[i]==ESC_STATIC){
257 dwType=DECLARE_STATIC;
258 i++;
259 }
260 else dwType=DECLARE_DYNAMIC;
261
262 //Sub/Function
263 if(buffer[i]==ESC_SUB) IsFunction=0;
264 else if(buffer[i]==ESC_FUNCTION) IsFunction=1;
265 else{
266 SetError(1,NULL,NowLine);
267 return;
268 }
269 i++;
270
271 //プロシージャ名
272 for(i2=0;;i++,i2++){
273 if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
274 bCdecl=1;
275
276 i+=2;
277 temporary[i2]=0;
278 break;
279 }
280 if(buffer[i]==','){
281 temporary[i2]=0;
282 break;
283 }
284 if(buffer[i]=='\0'){
285 SetError(1,NULL,NowLine);
286 return;
287 }
288 temporary[i2]=buffer[i];
289 }
290
291 //ユーザー定義関数との重複チェック
292 if(GetSubHash(temporary)){
293 SetError(15,temporary,NowLine);
294 return;
295 }
296
297
298 /////////////////////////////////
299 // 格納位置を計算してpciにセット
300 /////////////////////////////////
301
302 //ハッシュ値を取得
303 int key;
304 key=hash_default(temporary);
305
306 extern DECLAREINFO **ppDeclareHash;
307 DECLAREINFO *pdi;
308 if(ppDeclareHash[key]){
309 pdi=ppDeclareHash[key];
310 while(1){
311 if(lstrcmpi(pdi->name,temporary)==0){
312 //重複エラー
313 SetError(15,temporary,NowLine);
314 return;
315 }
316
317 if(pdi->pNextData==0){
318 pdi->pNextData=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
319 break;
320 }
321 pdi=pdi->pNextData;
322 }
323 pdi=pdi->pNextData;
324 }
325 else{
326 ppDeclareHash[key]=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
327 pdi=ppDeclareHash[key];
328 }
329
330 pdi->dwType=dwType;
331 pdi->bCdecl=bCdecl;
332
333 pdi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
334 lstrcpy(pdi->name,temporary);
335 i++;
336
337 //ライブラリ
338 if(buffer[i]!='\"'){
339 SetError(1,NULL,NowLine);
340 return;
341 }
342 for(i++,i2=0;;i++,i2++){
343 if(buffer[i]=='\"'){
344 temporary[i2]=0;
345 break;
346 }
347 if(buffer[i]=='\0'){
348 SetError(1,NULL,NowLine);
349 return;
350 }
351 temporary[i2]=buffer[i];
352 }
353 CharUpper(temporary);
354 if(!strstr(temporary,".")){
355 if(pdi->dwType==DECLARE_STATIC) lstrcat(temporary,".LIB");
356 else{
357 lstrcat(temporary,".DLL");
358 if(lstrlen(temporary)>=16){
359 SetError(7,NULL,NowLine);
360 return;
361 }
362 }
363 }
364 pdi->file=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
365 lstrcpy(pdi->file,temporary);
366 i++;
367
368 if(buffer[i]==','){
369 i++;
370 if(buffer[i]!='\"'){
371 SetError(1,NULL,NowLine);
372 return;
373 }
374 for(i++,i2=0;;i++,i2++){
375 if(buffer[i]=='\"'){
376 temporary[i2]=0;
377 break;
378 }
379 if(buffer[i]=='\0'){
380 SetError(1,NULL,NowLine);
381 return;
382 }
383 temporary[i2]=buffer[i];
384 }
385 pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
386 lstrcpy(pdi->alias,temporary);
387 i++;
388 }
389 else{
390 pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(pdi->name)+1);
391 lstrcpy(pdi->alias,pdi->name);
392 }
393
394 //パラメータの始めのカッコ
395 if(buffer[i]!='('){
396 SetError(1,NULL,NowLine);
397 return;
398 }
399 i++;
400
401 pdi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);
402
403 //各パラメータ
404 for(i3=0;;i3++){
405 if(buffer[i]==')') break;
406
407 pdi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pdi->pParmInfo,(i3+1)*sizeof(PARAMETER_INFO));
408
409 //ByVal
410 if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
411 pdi->pParmInfo[i3].bByVal=1;
412 i+=2;
413 }
414 else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
415 pdi->pParmInfo[i3].bByVal=0;
416 i+=2;
417 }
418 else pdi->pParmInfo[i3].bByVal=1;
419
420 //変数名は無視（temporaryの変数名は型宣言文字判断のため）
421 sw=0;
422 for(i2=0;;i++,i2++){
423 if(buffer[i]=='('){
424 if(!sw) sw=1;
425
426 i4=GetStringInPare(temporary+i2,buffer+i);
427 i2+=i4-1;
428 i+=i4-1;
429 continue;
430 }
431 if(buffer[i]=='['){
432 if(!sw) sw=1;
433
434 i4=GetStringInBracket(temporary+i2,buffer+i);
435 i2+=i4-1;
436 i+=i4-1;
437 continue;
438 }
439 if(!IsVariableChar(buffer[i])){
440 temporary[i2]=0;
441 break;
442 }
443 temporary[i2]=buffer[i];
444 }
445 if(lstrcmp(temporary,"...")==0) pdi->pParmInfo[i3].type=DEF_ELLIPSE;
446 else{
447 //型
448 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
449 i+=2;
450 for(i2=0;;i++,i2++){
451 if(!(IsVariableChar(buffer[i])||buffer[i]=='*')){
452 temporary[i2]=0;
453 break;
454 }
455 temporary[i2]=buffer[i];
456 }
457 pdi->pParmInfo[i3].type=GetTypeFixed(temporary,&pdi->pParmInfo[i3].u.index);
458 }
459 else{
460 pdi->pParmInfo[i3].type=GetTypeFromSimpleName(temporary);
461 SetError(-103,temporary,NowLine);
462 }
463
464 if(sw){
465 //配列ポインタを引き渡すとき
466 pdi->pParmInfo[i3].type=GetPtrType(pdi->pParmInfo[i3].type,pdi->pParmInfo[i3].u.index);
467 }
468 }
469
470 //名前はダミー（使用しないため）
471 pdi->pParmInfo[i3].name="";
472
473 //構造体の場合はエラーチェック
474 if(pdi->pParmInfo[i3].type==-1) SetError(3,temporary,NowLine);
475 if(pdi->pParmInfo[i3].type==DEF_OBJECT){
476 if(pdi->pParmInfo[i3].bByVal) pdi->pParmInfo[i3].type=DEF_LONG;//SetError(28,temporary,NowLine);
477 }
478
479 //構造体アドレスの空白部
480 while(buffer[i]==' ') i++;
481
482 if(buffer[i]==','){
483 i++;
484 continue;
485 }
486 else if(buffer[i]==')') continue;
487 else{
488 SetError(1,NULL,NowLine);
489 break;
490 }
491 }
492 pdi->ParmNum=i3;
493
494 //戻り値
495 i++;
496 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
497 if(IsFunction==0) SetError(1,NULL,NowLine);
498 i+=2;
499 pdi->ReturnType=GetTypeFixed(buffer+i,&pdi->u.ReturnIndex);
500 if(pdi->ReturnType==-1) SetError(3,buffer+i,NowLine);
501 if(pdi->ReturnType==DEF_OBJECT) SetError(40,NULL,NowLine);
502 }
503 else if(buffer[i]) SetError(1,NULL,NowLine);
504 else pdi->ReturnType=-1;
505
506 pdi->pos=NowLine;
507}
508
509BOOL CompareParameter(PARAMETER_INFO *ppi1,int pi_num1,PARAMETER_INFO *ppi2,int pi_num2){
510 if(pi_num1!=pi_num2) return 1;
511
512 int i;
513 for(i=0;i<pi_num1;i++){
514 if(ppi1[i].type!=ppi2[i].type){
515
516 if(ppi1[i].bByVal==0&&ppi1[i].type==DEF_ANY&&
517 ppi2[i].bByVal==1&&IsPtrType(ppi2[i].type)||
518 ppi1[i].bByVal==1&&IsPtrType(ppi1[i].type)&&
519 ppi2[i].bByVal==0&&ppi2[i].type==DEF_ANY){
520 /* ByRef var As Any
521 と
522 var As VoidPtr
523 は同等
524 */
525 continue;
526 }
527
528 return 1;
529 }
530 else{
531 if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
532 if(ppi1[i].u.index!=ppi2[i].u.index) return 1;
533 }
534 }
535 }
536
537 return 0;
538}
539SUBINFO *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
540 int i,i2,i3,sw;
541 DWORD dwType;
542 char temporary[8192],temp2[VN_SIZE];
543
544 i=1;
545 if(buffer[i]==ESC_SUB) dwType=SUBTYPE_SUB;
546 else if(buffer[i]==ESC_FUNCTION) dwType=SUBTYPE_FUNCTION;
547 else if(buffer[i]==ESC_MACRO) dwType=SUBTYPE_MACRO;
548
549 i++;
550
551 BOOL bExport=0,bCdecl=0;
552 while(1){
553 if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&&bExport==0){
554 bExport=1;
555
556 i+=2;
557 }
558 else if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&&bCdecl==0){
559 bCdecl=1;
560
561 i+=2;
562 }
563 else break;
564 }
565
566 i2=0;
567 if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
568 if(!pobj_c){
569 SetError(126,NULL,NowLine);
570 return 0;
571 }
572
573 //オペレータの場合
574 temporary[i2++]=buffer[i++];
575 temporary[i2++]=buffer[i++];
576
577 int iCalcId;
578 if(buffer[i]=='='&&buffer[i+1]=='='){
579 iCalcId=CALC_EQUAL;
580 i3=2;
581 }
582 else if(buffer[i]=='='){
583 iCalcId=CALC_SUBSITUATION;
584 i3=1;
585 }
586 else if(buffer[i]=='('){
587 iCalcId=CALC_AS;
588 i3=0;
589 }
590 else if(buffer[i]=='['&&buffer[i+1]==']'&&buffer[i+2]=='='){
591 iCalcId=CALC_ARRAY_SET;
592 i3=3;
593 }
594 else if(buffer[i]=='['&&buffer[i+1]==']'){
595 iCalcId=CALC_ARRAY_GET;
596 i3=2;
597 }
598 else{
599 iCalcId=GetCalcId(buffer+i,&i3);
600 i3++;
601 }
602 if(!iCalcId){
603 SetError(1,NULL,NowLine);
604 return 0;
605 }
606 temporary[i2++]=iCalcId;
607 temporary[i2]=0;
608
609 i+=i3;
610 }
611 else{
612 if(pobj_c){
613 //クラスメンバの場合、デストラクタには~が付くことを考慮
614 if(buffer[i]=='~'){
615 temporary[i2]='~';
616 i++;
617 i2++;
618 }
619 }
620
621 for(;;i++,i2++){
622 if(!IsVariableChar(buffer[i])){
623 temporary[i2]=0;
624 break;
625 }
626 temporary[i2]=buffer[i];
627 }
628 }
629
630 if(dwType==SUBTYPE_MACRO){
631 //大文字に変換
632 CharUpper(temporary);
633
634 //マクロ関数の場合は名前リストに追加
635 extern char **ppMacroNames;
636 extern int MacroNum;
637 ppMacroNames=(char **)HeapReAlloc(hHeap,0,ppMacroNames,(MacroNum+1)*sizeof(char *));
638 ppMacroNames[MacroNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
639 lstrcpy(ppMacroNames[MacroNum],temporary);
640 MacroNum++;
641 }
642
[30]643 if(!pobj_c){
[4]644 //クラスメンバ以外の場合のみ
645 //重複チェック
646
647 if(GetDeclareHash(temporary)){
648 SetError(15,temporary,NowLine);
649 return 0;
650 }
651 }
652
653 extern int SubNum;
654 SubNum++;
655
656 SUBINFO *psi;
657 psi=(SUBINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(SUBINFO));
658
659 //クラス名
660 psi->pobj_ParentClass=pobj_c;
661
662 //ID
[5]663 static int id_base=0;
[4]664 psi->id=(id_base++);
665
666 //関数名
667 psi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
668 lstrcpy(psi->name,temporary);
669
670 //ソースコードの位置
671 psi->address=NowLine;
672
673 psi->bExport=bExport;
674 psi->bCdecl=bCdecl;
675 psi->bVirtual=bVirtual;
676 if(bExport) psi->bUse=1;
677 else psi->bUse=0;
678 psi->bCompile=0;
679 psi->bSystem=0;
680
681 psi->dwType=dwType;
682
683
684 if(psi->dwType==SUBTYPE_FUNCTION){
685 ///////////////////
686 // 戻り値を取得
687 ///////////////////
688
689 if(pobj_c){
690 if(lstrcmp(psi->name,pobj_c->name)==0||
691 psi->name[0]=='~'){
692 //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
693 SetError(115,NULL,NowLine);
694 }
695 }
696
697
698 i2=lstrlen(buffer)-2;
699
700 int sw_as=0;
701 for(;i2>0;i2--){
702 if(buffer[i2]==')') break;
703 if(buffer[i2]==1&&buffer[i2+1]==ESC_AS){
704 i2+=2;
705 i3=0;
706 while(buffer[i2]=='*') temporary[i3++]=buffer[i2++];
707 for(;;i2++,i3++){
708 if(!IsVariableChar(buffer[i2])){
709 temporary[i3]=0;
710 break;
711 }
712 temporary[i3]=buffer[i2];
713 }
714 psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
715 if(psi->ReturnType==-1) SetError(3,temporary,NowLine);
716
717 sw_as=1;
718 break;
719 }
720 }
721
722 if(!sw_as){
723 SetError(-104,psi->name,NowLine);
724
725 psi->ReturnType=DEF_DOUBLE;
726 }
727 }
728 else{
729 //戻り値なしのSub定義
730 psi->ReturnType=-1;
731 psi->u.ReturnIndex=-1;
732 }
733
734
735
736 psi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(PARAMETER_INFO)*2);
737 psi->ParmNum=0;
738
739 //パラメータ
740 if(buffer[i]!='('){
741 SetError(1,NULL,NowLine);
742 return 0;
743 }
744 i++;
745 if(buffer[i]!=')'&&pobj_c){
746 //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
747 if(psi->name[0]=='~'){
748 SetError(114,NULL,NowLine);
749 i=JumpStringInPare(buffer,i);
750 }
751 }
752 while(1){
753 if(buffer[i]==')') break;
754
755 psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
756
757 //ByVal
758 if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
759 psi->pParmInfo[psi->ParmNum].bByVal=1;
760 i+=2;
761 }
762 else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
763 psi->pParmInfo[psi->ParmNum].bByVal=0;
764 i+=2;
765 }
766 else psi->pParmInfo[psi->ParmNum].bByVal=1;
767
768 //パラメータ名
769 sw=0;
770 for(i2=0;;i++,i2++){
771 if(buffer[i]=='('){
772 if(!sw) sw=1;
773
774 i3=GetStringInPare(temporary+i2,buffer+i);
775 i2+=i3-1;
776 i+=i3-1;
777 continue;
778 }
779 if(buffer[i]=='['){
780 if(!sw) sw=1;
781
782 i3=GetStringInBracket(temporary+i2,buffer+i);
783 i2+=i3-1;
784 i+=i3-1;
785 continue;
786 }
787 if(!IsVariableChar(buffer[i])){
788 temporary[i2]=0;
789 break;
790 }
791 temporary[i2]=buffer[i];
792 }
793 if(sw){
794 //配列パラメータ
795 if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
796 psi->pParmInfo[psi->ParmNum].bArray=1;
797
798 if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
799 (temporary[i2-2]=='['&&temporary[i2-1]==']')){
800 psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
801 psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
802
803 temporary[i2-2]=0;
804 }
805 else{
806 GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
807 lstrcpy(temporary,temp2);
808 }
809
810 i2=lstrlen(temporary);
811 }
812 else{
813 psi->pParmInfo[psi->ParmNum].bArray=0;
814 psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
815 }
816 psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
817 lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
818
819 //型
820 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
821 i+=2;
822
823 i2=0;
824 while(buffer[i]=='*'){
825 temporary[i2]=buffer[i];
826 i++;
827 i2++;
828 }
829 for(;;i++,i2++){
830 if(!IsVariableChar(buffer[i])){
831 if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
832 temporary[i2++]=buffer[i++];
833 temporary[i2]=buffer[i];
834 continue;
835 }
836 temporary[i2]=0;
837 break;
838 }
839 temporary[i2]=buffer[i];
840 }
841
842 psi->pParmInfo[psi->ParmNum].type=
843 GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
844
845 if(temporary[0]=='*'&&
846 temporary[1]==1&&
847 (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
848 if(buffer[i]!='('){
849 SetError(10,temporary,NowLine);
850 return 0;
851 }
852 i3=GetStringInPare(temporary+i2,buffer+i);
853 i+=i3;
854 i2+=i3;
855
856 if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
857 temporary[i2++]=buffer[i++];
858 temporary[i2++]=buffer[i++];
859 for(;;i++,i2++){
860 if(!IsVariableChar(buffer[i])){
861 temporary[i2]=0;
862 break;
863 }
864 temporary[i2]=buffer[i];
865 }
866 }
867 }
868 else{
869 //TypeDefをする前のベース型を取得
870 GetOriginalTypeName(temporary);
871 }
872
873 if(psi->pParmInfo[psi->ParmNum].type==-1){
874 SetError(3,temporary,NowLine);
875 psi->pParmInfo[psi->ParmNum].type=DEF_PTR_VOID;
876 }
877
878 /*未完成（構造体パラメータを値参照として渡してよいものか！？）
879 if(psi->pParmInfo[psi->ParmNum].type==DEF_OBJECT){
880 if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(28,temporary,NowLine);
881 }*/
882 }
883 else{
884 psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
885 SetError(-103,temporary,NowLine);
886 }
887
888 if(psi->pParmInfo[psi->ParmNum].type==DEF_PTR_PROC){
889 //関数ポインタの場合
890 psi->pParmInfo[psi->ParmNum].u.index=AddProcPtrInfo(temporary+3,temporary[2]);
891 }
892
893 //パラメータの数を更新
894 psi->ParmNum++;
895
896 if(buffer[i]==','){
897 i++;
898 continue;
899 }
900 else if(buffer[i]==')') continue;
901 else{
902 SetError(1,NULL,NowLine);
903 return 0;
904 }
905 }
906 psi->SecondParmNum=psi->ParmNum;
907 i++;
908 if(buffer[i]=='('){
909 i++;
910 while(1){
911 if(buffer[i]==')') break;
912
913 psi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,psi->pParmInfo,(psi->ParmNum+1)*sizeof(PARAMETER_INFO));
914
915 //ByVal
916 if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
917 psi->pParmInfo[psi->ParmNum].bByVal=1;
918 i+=2;
919 }
920 else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
921 psi->pParmInfo[psi->ParmNum].bByVal=0;
922 i+=2;
923 }
924 else psi->pParmInfo[psi->ParmNum].bByVal=1;
925
926 //パラメータ名
927 sw=0;
928 for(i2=0;;i++,i2++){
929 if(buffer[i]=='('){
930 if(!sw) sw=1;
931
932 i3=GetStringInPare(temporary+i2,buffer+i);
933 i2+=i3-1;
934 i+=i3-1;
935 continue;
936 }
937 if(buffer[i]=='['){
938 if(!sw) sw=1;
939
940 i3=GetStringInBracket(temporary+i2,buffer+i);
941 i2+=i3-1;
942 i+=i3-1;
943 continue;
944 }
945 if(!IsVariableChar(buffer[i])){
946 temporary[i2]=0;
947 break;
948 }
949 temporary[i2]=buffer[i];
950 }
951 if(sw){
952 //配列パラメータ
953 if(psi->pParmInfo[psi->ParmNum].bByVal) SetError(29,NULL,NowLine);
954 psi->pParmInfo[psi->ParmNum].bArray=1;
955
956 if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
957 (temporary[i2-2]=='['&&temporary[i2-1]==']')){
958 psi->pParmInfo[psi->ParmNum].SubScripts[0]=LONG_MAX;
959 psi->pParmInfo[psi->ParmNum].SubScripts[1]=-1;
960
961 temporary[i2-2]=0;
962 }
963 else{
964 GetArrange(temporary,temp2,psi->pParmInfo[psi->ParmNum].SubScripts);
965 lstrcpy(temporary,temp2);
966 }
967
968 i2=lstrlen(temporary);
969 }
970 else{
971 psi->pParmInfo[psi->ParmNum].bArray=0;
972 psi->pParmInfo[psi->ParmNum].SubScripts[0]=-1;
973 }
974 psi->pParmInfo[psi->ParmNum].name=(char *)HeapAlloc(hHeap,0,i2+1);
975 lstrcpy(psi->pParmInfo[psi->ParmNum].name,temporary);
976
977 //型
978 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
979 i+=2;
980 i2=0;
981 while(buffer[i]=='*'){
982 temporary[i2]=buffer[i];
983 i++;
984 i2++;
985 }
986 for(;;i++,i2++){
987 if(!IsVariableChar(buffer[i])){
988 temporary[i2]=0;
989 break;
990 }
991 temporary[i2]=buffer[i];
992 }
993 psi->pParmInfo[psi->ParmNum].type=
994 GetTypeFixed(temporary,&psi->pParmInfo[psi->ParmNum].u.index);
995 if(psi->pParmInfo[psi->ParmNum].type==-1) SetError(3,temporary,NowLine);
996 }
997 else{
998 psi->pParmInfo[psi->ParmNum].type=GetTypeFromSimpleName(temporary);
999 SetError(-103,temporary,NowLine);
1000 }
1001
1002 psi->ParmNum++;
1003
1004 if(buffer[i]==','){
1005 i++;
1006 continue;
1007 }
1008 else if(buffer[i]==')') continue;
1009 else{
1010 SetError(1,NULL,NowLine);
1011 return 0;
1012 }
1013 }
1014 i++;
1015 }
1016
[31]1017 //リアルパラメータ領域を取得（_System_LocalThis、_System_ReturnValueを考慮して2つだけ多く確保する）
1018 psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
1019 psi->RealParmNum=0;
[4]1020
[31]1021 if(pobj_c&&bStatic==0){
1022 i = psi->RealParmNum;
[4]1023
[31]1024 //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
1025 psi->pRealParmInfo[i].name = "_System_LocalThis";
1026 psi->pRealParmInfo[i].type=DEF_PTR_VOID;
1027 psi->pRealParmInfo[i].u.index=-1;
1028 psi->pRealParmInfo[i].bByVal=1;
1029 psi->pRealParmInfo[i].bArray=0;
1030 psi->pRealParmInfo[i].SubScripts[0]=-1;
[4]1031
[31]1032 psi->RealParmNum++;
1033 }
[4]1034
[31]1035 if(psi->ReturnType==DEF_OBJECT){
1036 i = psi->RealParmNum;
1037
1038 //実体オブジェクトを戻り値として持つ場合
1039 //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
1040
[4]1041 if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
1042 psi->pRealParmInfo[i].name="_System_ReturnValue";
1043 else psi->pRealParmInfo[i].name=psi->name;
1044 psi->pRealParmInfo[i].type=DEF_OBJECT;
1045 psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
1046 psi->pRealParmInfo[i].bByVal=0;
1047 psi->pRealParmInfo[i].bArray=0;
1048 psi->pRealParmInfo[i].SubScripts[0]=-1;
[31]1049
1050 psi->RealParmNum++;
1051 }
[4]1052
[31]1053 //パラメータをコピー
1054 for( i = 0; i < psi->ParmNum; i++, psi->RealParmNum++ ){
1055 psi->pRealParmInfo[psi->RealParmNum]=psi->pParmInfo[i];
[4]1056 }
1057
1058
1059 /////////////////////////////////
1060 // ハッシュデータに追加
1061 /////////////////////////////////
1062
1063 int key;
1064 key=hash_default(psi->name);
1065
1066 extern SUBINFO **ppSubHash;
1067 if(ppSubHash[key]){
1068 SUBINFO *psi2;
1069 psi2=ppSubHash[key];
1070 while(1){
1071 if(pobj_c==psi2->pobj_ParentClass){
1072 //重複エラーチェックを行う
1073 if(lstrcmp(psi2->name,psi->name)==0){
1074 if(CompareParameter(psi2->pParmInfo,psi2->ParmNum,psi->pParmInfo,psi->ParmNum)==0){
1075 SetError(15,psi->name,NowLine);
1076 return 0;
1077 }
1078 }
1079 }
1080
1081 if(psi2->pNextData==0) break;
1082 psi2=psi2->pNextData;
1083 }
1084 psi2->pNextData=psi;
1085 }
1086 else{
1087 ppSubHash[key]=psi;
1088 }
1089
1090 return psi;
1091}
1092
1093void GetSubInfo(void){ //サブルーチン情報を取得
1094 extern HANDLE hHeap;
1095 extern char *basbuf;
1096 int i,i2,i3;
1097 char temporary[8192];
1098
1099 //Declare（DLL関数）情報を初期化
1100 extern DECLAREINFO **ppDeclareHash;
1101 ppDeclareHash=(DECLAREINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DECLAREINFO *));
1102
1103 //サブルーチン（ユーザー定義）情報を初期化
1104 extern SUBINFO **ppSubHash;
1105 extern int SubNum;
1106 ppSubHash=(SUBINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SUBINFO *));
1107 SubNum=0;
1108
1109 //マクロ関数の名前リストを初期化
1110 extern char **ppMacroNames;
1111 extern int MacroNum;
1112 ppMacroNames=(char **)HeapAlloc(hHeap,0,1);
1113 MacroNum=0;
1114
1115 i=-1;
1116 while(1){
1117 i++;
1118
1119 if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_INTERFACE)){
1120 /* Class ～ End Class
1121 Interface ～ End Interface
1122 を飛び越す */
1123 i3=GetEndXXXCommand(basbuf[i+1]);
1124 for(i+=2,i2=0;;i++,i2++){
1125 if(basbuf[i]=='\0') break;
1126 if(basbuf[i]==1&&basbuf[i+1]==(char)i3){
1127 i++;
1128 break;
1129 }
1130 }
1131 if(basbuf[i]=='\0') break;
1132 continue;
1133 }
1134
1135 if(basbuf[i]==1&&basbuf[i+1]==ESC_DECLARE){
1136 for(i+=2,i2=0;;i2++,i++){
1137 if(basbuf[i]=='\n'){
1138 temporary[i2]=0;
1139 break;
1140 }
1141 temporary[i2]=basbuf[i];
1142 if(basbuf[i]=='\0') break;
1143 }
1144 AddDeclareData(temporary,i);
1145
1146 continue;
1147 }
1148 if(basbuf[i]==1&&(basbuf[i+1]==ESC_SUB||basbuf[i+1]==ESC_FUNCTION||basbuf[i+1]==ESC_MACRO)){
1149 for(i2=0;;i2++,i++){
1150 if(IsCommandDelimitation(basbuf[i])){
1151 temporary[i2]=0;
1152 break;
1153 }
1154 temporary[i2]=basbuf[i];
1155 if(basbuf[i]=='\0') break;
1156 }
1157 AddSubData(temporary,i,0,0);
1158
1159 continue;
1160 }
1161
1162 //次の行
1163 for(;;i++){
1164 if(IsCommandDelimitation(basbuf[i])) break;
1165 }
1166 if(basbuf[i]=='\0') break;
1167 }
1168
1169 ////////////
1170 // 特殊関数
1171 ////////////
1172
1173 sprintf(temporary,"%c%c_allrem()",1,ESC_SUB);
1174 AddSubData(temporary,0,0,0);
1175
1176 sprintf(temporary,"%c%c_aullrem()",1,ESC_SUB);
1177 AddSubData(temporary,0,0,0);
1178
1179 sprintf(temporary,"%c%c_allmul()",1,ESC_SUB);
1180 AddSubData(temporary,0,0,0);
1181
1182 sprintf(temporary,"%c%c_alldiv()",1,ESC_SUB);
1183 AddSubData(temporary,0,0,0);
1184
1185 sprintf(temporary,"%c%c_aulldiv()",1,ESC_SUB);
1186 AddSubData(temporary,0,0,0);
1187
1188 sprintf(temporary,"%c%c_allshl()",1,ESC_SUB);
1189 AddSubData(temporary,0,0,0);
1190
1191 sprintf(temporary,"%c%c_allshr()",1,ESC_SUB);
1192 AddSubData(temporary,0,0,0);
1193
1194 sprintf(temporary,"%c%c_aullshr()",1,ESC_SUB);
1195 AddSubData(temporary,0,0,0);
1196
1197 sprintf(temporary,"%c%c_System_InitStaticLocalVariables()",1,ESC_SUB);
1198 AddSubData(temporary,0,0,0);
1199}
1200void Delete_si(SUBINFO *psi){
1201 int i2;
1202
1203 for(i2=0;i2<psi->ParmNum;i2++){
1204 HeapDefaultFree(psi->pParmInfo[i2].name);
1205 }
[31]1206 HeapDefaultFree(psi->pRealParmInfo);
[4]1207 if(psi->pParmInfo) HeapDefaultFree(psi->pParmInfo);
1208 psi->pRealParmInfo=0;
1209 psi->pParmInfo=0;
1210
1211 if(psi->pNextData) Delete_si(psi->pNextData);
1212
1213 HeapDefaultFree(psi->name);
1214 HeapDefaultFree(psi);
1215}
1216void DeleteSubInfo(SUBINFO **ppSubHash,char **ppMacroNames,int MacroNum){ //サブルーチン情報のメモリ解放
1217 int i;
1218 for(i=0;i<MAX_HASH;i++){
1219 if(!ppSubHash[i]) continue;
1220
1221 Delete_si(ppSubHash[i]);
1222 }
1223 HeapDefaultFree(ppSubHash);
1224
1225 //マクロの名前リスト
1226 if(ppMacroNames){
1227 for(i=0;i<MacroNum;i++){
1228 HeapDefaultFree(ppMacroNames[i]);
1229 }
1230 HeapDefaultFree(ppMacroNames);
1231 }
1232}
1233void Delete_di(DECLAREINFO *pdi){
1234 if(pdi->pParmInfo) HeapDefaultFree(pdi->pParmInfo);
1235
1236 HeapDefaultFree(pdi->name);
1237 if(pdi->file) HeapDefaultFree(pdi->file);
1238 if(pdi->alias) HeapDefaultFree(pdi->alias);
1239
1240 if(pdi->pNextData) Delete_di(pdi->pNextData);
1241
1242 HeapDefaultFree(pdi);
1243}
1244void DeleteDeclareInfo(void){
1245 //DLL情報を解放
1246 extern DECLAREINFO **ppDeclareHash;
1247 int i;
1248 for(i=0;i<MAX_HASH;i++){
1249 if(!ppDeclareHash[i]) continue;
1250
1251 Delete_di(ppDeclareHash[i]);
1252 }
1253 HeapDefaultFree(ppDeclareHash);
1254}
1255
1256
1257
1258///////////////////////
1259// 関数ポインタの管理
1260///////////////////////
1261
1262int AddProcPtrInfo(char *buffer,DWORD dwProcType){
1263 extern HANDLE hHeap;
1264 extern int cp;
1265 extern PROCPTRINFO *pProcPtrInfo;
1266 extern int ProcPtrInfoNum;
1267 int i,i2,i3,sw;
1268 PROCPTRINFO *pi;
1269 char temporary[VN_SIZE],temp2[VN_SIZE];
1270
1271 pProcPtrInfo=(PROCPTRINFO *)HeapReAlloc(hHeap,0,pProcPtrInfo,(ProcPtrInfoNum+1)*sizeof(PROCPTRINFO));
1272 pi=&pProcPtrInfo[ProcPtrInfoNum];
1273 ProcPtrInfoNum++;
1274
1275 pi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);
1276 pi->ParmNum=0;
1277
1278 //buffer[0]は'('となっている
1279 i=1;
1280
1281 while(1){
1282 if(buffer[i]==')') break;
1283
1284 pi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pi->pParmInfo,(pi->ParmNum+1)*sizeof(PARAMETER_INFO));
1285
1286 //ByVal
1287 if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
1288 pi->pParmInfo[pi->ParmNum].bByVal=1;
1289 i+=2;
1290 }
1291 else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
1292 pi->pParmInfo[pi->ParmNum].bByVal=0;
1293 i+=2;
1294 }
1295 else pi->pParmInfo[pi->ParmNum].bByVal=1;
1296
1297 //パラメータ名
1298 sw=0;
1299 for(i2=0;;i++,i2++){
1300 if(buffer[i]=='('){
1301 if(!sw) sw=1;
1302
1303 i3=GetStringInPare(temporary+i2,buffer+i);
1304 i2+=i3-1;
1305 i+=i3-1;
1306 continue;
1307 }
1308 if(buffer[i]=='['){
1309 if(!sw) sw=1;
1310
1311 i3=GetStringInBracket(temporary+i2,buffer+i);
1312 i2+=i3-1;
1313 i+=i3-1;
1314 continue;
1315 }
1316 if(!IsVariableChar(buffer[i])){
1317 temporary[i2]=0;
1318 break;
1319 }
1320 temporary[i2]=buffer[i];
1321 }
1322 pi->pParmInfo[pi->ParmNum].name=0;
1323
1324 if(sw){
1325 //配列パラメータ
1326 if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(29,NULL,cp);
1327 pi->pParmInfo[pi->ParmNum].bArray=1;
1328
1329 if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
1330 (temporary[i2-2]=='['&&temporary[i2-1]==']')){
1331 pi->pParmInfo[pi->ParmNum].SubScripts[0]=LONG_MAX;
1332 pi->pParmInfo[pi->ParmNum].SubScripts[1]=-1;
1333
1334 temporary[i2-2]=0;
1335 }
1336 else{
1337 GetArrange(temporary,temp2,pi->pParmInfo[pi->ParmNum].SubScripts);
1338 lstrcpy(temporary,temp2);
1339 }
1340
1341 i2=lstrlen(temporary);
1342 }
1343 else{
1344 pi->pParmInfo[pi->ParmNum].bArray=0;
1345 pi->pParmInfo[pi->ParmNum].SubScripts[0]=-1;
1346 }
1347
1348 //型
1349 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
1350 i+=2;
1351
1352 i2=0;
1353 while(buffer[i]=='*'){
1354 temporary[i2]=buffer[i];
1355 i++;
1356 i2++;
1357 }
1358 for(;;i++,i2++){
1359 if(!IsVariableChar(buffer[i])){
1360 temporary[i2]=0;
1361 break;
1362 }
1363 temporary[i2]=buffer[i];
1364 }
1365
1366 pi->pParmInfo[pi->ParmNum].type=
1367 GetTypeFixed(temporary,&pi->pParmInfo[pi->ParmNum].u.index);
1368 if(pi->pParmInfo[pi->ParmNum].type==-1){
1369 SetError(3,temporary,cp);
1370 pi->pParmInfo[pi->ParmNum].type=DEF_PTR_VOID;
1371 }
1372 if(pi->pParmInfo[pi->ParmNum].type==DEF_OBJECT){
1373 if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(28,temporary,cp);
1374 }
1375 }
1376 else{
1377 pi->pParmInfo[pi->ParmNum].type=GetTypeFromSimpleName(temporary);
1378 SetError(-103,temporary,cp);
1379 }
1380
1381 pi->ParmNum++;
1382
1383 if(buffer[i]==','){
1384 i++;
1385 continue;
1386 }
1387 else if(buffer[i]==')') continue;
1388 else{
1389 SetError(1,NULL,cp);
1390 return 0;
1391 }
1392 }
1393 i++;
1394
1395 //戻り値
1396 if(dwProcType==ESC_FUNCTION){
1397 if(buffer[i]==1&&buffer[i+1]==ESC_AS){
1398 i+=2;
1399 i2=0;
1400 if(buffer[i]=='*') temporary[i2++]=buffer[i++];
1401 for(;;i++,i2++){
1402 if(!IsVariableChar(buffer[i])){
1403 temporary[i2]=0;
1404 break;
1405 }
1406 temporary[i2]=buffer[i];
1407 }
1408 pi->ReturnType=GetTypeFixed(temporary,&pi->u.ReturnIndex);
1409 if(pi->ReturnType==-1) SetError(3,temporary,cp);
1410 if(pi->ReturnType==DEF_OBJECT) SetError(40,NULL,cp);
1411 }
1412 else pi->ReturnType=DEF_DOUBLE;
1413 }
1414 else pi->ReturnType=-1;
1415
1416 return ProcPtrInfoNum-1;
1417}
1418void DeleteProcPtrInfo(void){
1419 extern PROCPTRINFO *pProcPtrInfo;
1420 extern int ProcPtrInfoNum;
1421 int i;
1422
1423 for(i=0;i<ProcPtrInfoNum;i++){
1424 HeapDefaultFree(pProcPtrInfo[i].pParmInfo);
1425 }
1426
1427 HeapDefaultFree(pProcPtrInfo);
1428}
Note: See TracBrowser for help on using the repository browser.