Context Navigation

source: dev/BasicCompiler_Common/Subroutine.cpp@ 30

Last change on this file since 30 was 30, checked in by dai_9181, 17 years ago
グローバル領域で定義されている関数と同名の静的メソッドを定義することが出来ないバグを修正。
File size: 31.1 KB

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

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

Download in other formats: