source: dev/BasicCompiler_Common/Subroutine.cpp@ 78

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

CTypeDef → TypeDef
Houseクラスを追加。
オーバーロードレベルの種類を追加（レベル1に挿入）
File size: 17.0 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
9int GetCallProcName(char *buffer,char *name){
10 int i2,i3,IsStr=0;
11
12 for(i2=0;;i2++){
13 if(buffer[i2]=='\"') IsStr^=1;
14 if(IsDBCSLeadByte(buffer[i2])){
15 name[i2]=buffer[i2];
16 i2++;
17 name[i2]=buffer[i2];
18 continue;
19 }
20 if(buffer[i2]=='['&&IsStr==0){
21 i3=GetStringInBracket(name+i2,buffer+i2);
22 i2+=i3-1;
23 continue;
24 }
25 if(buffer[i2]=='('&&IsStr==0){
26 name[i2]=0;
27 break;
28 }
29 if(buffer[i2]=='='&&IsStr==0){
30 name[i2]=0;
31 break;
32 }
33
34 name[i2]=buffer[i2];
35 if(buffer[i2]=='\0') break;
36 }
37 return i2;
38}
39
40int GetProc(char *name,void **ppInfo){
41
42 //ユーザー定義関数
43 *ppInfo=(void *)GetSubHash(name);
44 if(*ppInfo) return PROC_DEFAULT;
45
46 //DLL関数
47 *ppInfo=(void *)GetDeclareHash(name);
48 if(*ppInfo) return PROC_DLL;
49
50 //コンパイラ埋め込み型
51 *ppInfo=(void *)(_int64)GetFunctionFromName(name);
52 if(*ppInfo) return PROC_BUILTIN;
53
54 //関数ポインタ
55 Type type;
56 if( !GetVarType( name, type, false ) ){
57 return 0;
58 }
59 if( type.IsProcPtr() ){
60 return PROC_PTR;
61 }
62
63 return 0;
64}
65
66void SplitObjectName(const 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}
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}
106
107bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn ){
108
109 //GetSubHash内でエラー提示が行われた場合
110 if(pProc==(Procedure *)-1){
111 return false;
112 }
113
114 if(kind==PROC_DEFAULT){
115 /////////////////////
116 // ユーザー定義関数
117 /////////////////////
118
119 UserProc *pUserProc = (UserProc *)pProc;
120
121 //オブジェクト名を取得
122 char ObjectName[VN_SIZE];
123 int RefType;
124 SplitObjectName(fullCallName,ObjectName,&RefType);
125
126
127 ////////////////////////
128 // オーバーロードを解決
129 ////////////////////////
130
131 std::vector<UserProc *> subs;
132 GetOverloadSubHash(fullCallName,subs);
133 if(subs.size()){
134 //オーバーロードを解決
135 pUserProc=OverloadSolutionWithStrParam(fullCallName,subs,lpszParms,ObjectName);
136
137 if(!pUserProc){
138 return false;
139 }
140 }
141
142 resultType = pUserProc->ReturnType();
143
144 if( isCallOn ){
145 if( !Opcode_CallProc(lpszParms,pUserProc,0,ObjectName,RefType) ){
146 return false;
147 }
148 }
149 }
150 else if(kind==PROC_DLL){
151 /////////////////////////
152 // DLL関数
153 /////////////////////////
154 DllProc *pDllProc = (DllProc *)pProc;
155
156 resultType = pDllProc->ReturnType();
157
158 if( isCallOn ){
159 if( !Opcode_CallDllProc(lpszParms,pDllProc) ){
160 return false;
161 }
162 }
163 }
164 else if(kind==PROC_BUILTIN){
165 /////////////////////////
166 // 組み込み関数
167 /////////////////////////
168 int FuncId = (int)(_int64)pProc;
169
170 if( !Opcode_CallFunc( lpszParms, FuncId, resultType, isCallOn ) ){
171 return false;
172 }
173 }
174 else if(kind==PROC_PTR){
175 /////////////////
176 // 関数ポインタ
177 /////////////////
178
179 Type type;
180 GetVarType(fullCallName,type,false);
181
182 ProcPointer *pProcPtr = House::procPointers[type.GetIndex()];
183 resultType = pProcPtr->ReturnType();
184
185 if( isCallOn ){
186 if( !Opcode_CallProcPtr(fullCallName,lpszParms,pProcPtr) ){
187 return false;
188 }
189 }
190 }
191 else{
192 return false;
193 }
194
195 return true;
196}
197bool CallPropertyMethod( const char *variable, const char *rightSide, Type &resultType){
198 //プロパティ用のメソッドを呼び出す
199
200 //配列要素を取得
201 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
202 GetArrayElement(variable,VarName,ArrayElements);
203
204 //オブジェクト名を取得
205 char ObjectName[VN_SIZE];
206 int RefType;
207 SplitObjectName(VarName,ObjectName,&RefType);
208
209 //オーバーロード用の関数リストを作成
210 std::vector<UserProc *> subs;
211 GetOverloadSubHash(VarName,subs);
212 if(subs.size()==0){
213 return false;
214 }
215
216 //パラメータを整備
217 char *Parameter;
218 Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(rightSide)+32);
219 lstrcpy(Parameter,ArrayElements);
220 if(rightSide){
221 if(Parameter[0]&&rightSide[0]) lstrcat(Parameter,",");
222 lstrcat(Parameter,rightSide);
223 }
224
225 //オーバーロードを解決
226 UserProc *pUserProc;
227 pUserProc=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName);
228
229 if(pUserProc){
230 //呼び出し
231 Opcode_CallProc(Parameter,pUserProc,0,ObjectName,RefType);
232
233 resultType = pUserProc->ReturnType();
234 }
235
236 HeapDefaultFree(Parameter);
237
238 return true;
239}
240
241bool GetReturnTypeOfPropertyMethod( const char *variable, const char *rightSide, Type &resultType ){
242 //プロパティ用のメソッドを呼び出す
243
244 //配列要素を取得
245 char VarName[VN_SIZE],ArrayElements[VN_SIZE];
246 GetArrayElement(variable,VarName,ArrayElements);
247
248 //オブジェクト名を取得
249 char ObjectName[VN_SIZE];
250 int RefType;
251 SplitObjectName(VarName,ObjectName,&RefType);
252
253 //オーバーロード用の関数リストを作成
254 std::vector<UserProc *> subs;
255 GetOverloadSubHash(VarName,subs);
256 if(subs.size()==0){
257 return 0;
258 }
259
260 //パラメータを整備
261 char *Parameter;
262 Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(rightSide)+32);
263 lstrcpy(Parameter,ArrayElements);
264 if(rightSide){
265 if(Parameter[0]&&rightSide[0]) lstrcat(Parameter,",");
266 lstrcat(Parameter,rightSide);
267 }
268
269 //オーバーロードを解決
270 UserProc *pUserProc;
271 pUserProc=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName);
272
273 if(pUserProc){
274 resultType = pUserProc->ReturnType();
275 }
276
277 return 1;
278}
279
280//インデクサ（getter）の戻り値を取得
281bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType ){
282 std::vector<UserProc *> subs;
283 objClass.EnumMethod( CALC_ARRAY_GET, subs );
284 if( subs.size() == 0 ){
285 return false;
286 }
287
288 resultType = subs[0]->ReturnType();
289
290 return true;
291}
292
293
294void AddDeclareData(char *buffer,int nowLine){
295 extern HANDLE hHeap;
296 int i2;
297
298 int i=0;
299
300 //Sub/Function
301 Procedure::Kind kind = Procedure::Sub;
302 if(buffer[i]==ESC_SUB){
303 }
304 else if(buffer[i]==ESC_FUNCTION){
305 kind = Procedure::Function;
306 }
307 else{
308 SetError(1,NULL,nowLine);
309 return;
310 }
311 i++;
312
313 //プロシージャ名
314 char procName[VN_SIZE];
315 bool isCdecl = false;
316 for(i2=0;;i++,i2++){
317 if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
318 isCdecl = true;
319
320 i+=2;
321 procName[i2]=0;
322 break;
323 }
324 if(buffer[i]==','){
325 procName[i2]=0;
326 break;
327 }
328 if(buffer[i]=='\0'){
329 SetError(1,NULL,nowLine);
330 return;
331 }
332 procName[i2]=buffer[i];
333 }
334 i++;
335
336 //ユーザー定義関数との重複チェック
337 if(GetSubHash(procName)){
338 SetError(15,procName,nowLine);
339 return;
340 }
341
342
343 //ライブラリ
344 char dllFileName[MAX_PATH];
345 i = GetOneParameter( buffer, i, dllFileName );
346 Type resultType;
347 _int64 i64data;
348 if( !StaticCalculation( true, dllFileName, 0, &i64data, resultType ) ){
349 return;
350 }
351 if( resultType.GetBasicType() != typeOfPtrChar ){
352 SetError(1,NULL,nowLine);
353 return;
354 }
355 lstrcpy( dllFileName, (char *)i64data );
356 CharUpper(dllFileName);
357 if(!strstr(dllFileName,".")){
358 lstrcat(dllFileName,".DLL");
359 if(lstrlen(dllFileName)>=16){
360 SetError(7,NULL,nowLine);
361 return;
362 }
363 }
364
365 //エイリアス
366 char alias[VN_SIZE];
367 i = GetOneParameter( buffer, i, alias );
368 if( alias[0] ){
369 if( !StaticCalculation( true, alias, 0, &i64data, resultType ) ){
370 return;
371 }
372 if( resultType.GetBasicType() != typeOfPtrChar ){
373 SetError(1,NULL,nowLine);
374 return;
375 }
376 lstrcpy( alias, (char *)i64data );
377 }
378 else{
379 //省略されたときは関数名
380 lstrcpy( alias, procName );
381 }
382
383
384 // オブジェクトを生成
385 DllProc *pDllProc = new DllProc( procName, kind, isCdecl, dllFileName, alias );
386
387 // パラメータを解析
388 // ※第1パラメータにに指定するデータの例："( s As String ) As String"
389 pDllProc->SetParamsAndReturnType( buffer + i, nowLine );
390
391 // パラメータのエラーチェック
392 foreach( const Parameter *pParam, pDllProc->Params() ){
393 if( pParam->IsObject() ){
394 SetError(25,pParam->GetVarName(),nowLine);
395 }
396 if( !pParam->IsRef() ){
397 if( pParam->IsStruct() ){
398 SetError(28,pParam->GetVarName(),nowLine);
399 }
400 }
401 }
402
403 //戻り値のエラーチェック
404 if( pDllProc->IsFunction() ){
405 // Function定義
406
407 if( pDllProc->ReturnType().IsObject() ){
408 // DLL関数ではオブジェクトを戻り値にできない
409 SetError(40,pDllProc->GetName(),nowLine);
410 }
411 }
412
413
414 /////////////////////////////////
415 // 格納位置を計算してppDeclareHashにセット
416 /////////////////////////////////
417
418 //ハッシュ値を取得
419 int key;
420 key=hash_default(procName);
421
422 extern DllProc **ppDeclareHash;
423 if(ppDeclareHash[key]){
424 DllProc *pTempProc;
425 pTempProc=ppDeclareHash[key];
426 while(1){
427 if( pDllProc->GetName() == pTempProc->GetName() ){
428 //重複エラー
429 SetError(15,procName,nowLine);
430 return;
431 }
432
433 if(pTempProc->pNextData==0){
434 pTempProc->pNextData=pDllProc;
435 break;
436 }
437 pTempProc=pTempProc->pNextData;
438 }
439 pTempProc=pTempProc->pNextData;
440 }
441 else{
442 ppDeclareHash[key]=pDllProc;
443 }
444}
445
446UserProc *AddSubData(char *buffer,int nowLine,BOOL bVirtual,CClass *pobj_c, bool isStatic){
447 int i2,i3;
448 char temporary[8192];
449
450 int i=1;
451
452 UserProc::Kind kind = Procedure::Sub;
453 bool isMacro = false;
454 if(buffer[i]==ESC_FUNCTION) kind = Procedure::Function;
455 if(buffer[i]==ESC_MACRO){
456 isMacro = true;
457 }
458
459 i++;
460
461 bool isCdecl = false;
462 bool isExport = false;
463 while(1){
464 if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&& isCdecl == false ){
465 isCdecl = true;
466
467 i+=2;
468 }
469 else if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&& isExport == false ){
470 isExport = true;
471
472 i+=2;
473 }
474 else break;
475 }
476
477 i2=0;
478 if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
479 if(!pobj_c){
480 SetError(126,NULL,nowLine);
481 return 0;
482 }
483
484 //オペレータの場合
485 temporary[i2++]=buffer[i++];
486 temporary[i2++]=buffer[i++];
487
488 int iCalcId;
489 if(buffer[i]=='='&&buffer[i+1]=='='){
490 iCalcId=CALC_EQUAL;
491 i3=2;
492 }
493 else if(buffer[i]=='='){
494 iCalcId=CALC_SUBSITUATION;
495 i3=1;
496 }
497 else if(buffer[i]=='('){
498 iCalcId=CALC_AS;
499 i3=0;
500 }
501 else if(buffer[i]=='['&&buffer[i+1]==']'&&buffer[i+2]=='='){
502 iCalcId=CALC_ARRAY_SET;
503 i3=3;
504 }
505 else if(buffer[i]=='['&&buffer[i+1]==']'){
506 iCalcId=CALC_ARRAY_GET;
507 i3=2;
508 }
509 else{
510 iCalcId=GetCalcId(buffer+i,&i3);
511 i3++;
512 }
513 if(!iCalcId){
514 SetError(1,NULL,nowLine);
515 return 0;
516 }
517 temporary[i2++]=iCalcId;
518 temporary[i2]=0;
519
520 i+=i3;
521 }
522 else{
523 if(pobj_c){
524 //クラスメンバの場合、デストラクタには~が付くことを考慮
525 if(buffer[i]=='~'){
526 temporary[i2]='~';
527 i++;
528 i2++;
529 }
530 }
531
532 for(;;i++,i2++){
533 if(!IsVariableChar(buffer[i])){
534 temporary[i2]=0;
535 break;
536 }
537 temporary[i2]=buffer[i];
538 }
539 }
540
541 if( isMacro ){
542 //大文字に変換
543 CharUpper(temporary);
544
545 //マクロ関数の場合は名前リストに追加
546 extern char **ppMacroNames;
547 extern int MacroNum;
548 ppMacroNames=(char **)HeapReAlloc(hHeap,0,ppMacroNames,(MacroNum+1)*sizeof(char *));
549 ppMacroNames[MacroNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
550 lstrcpy(ppMacroNames[MacroNum],temporary);
551 MacroNum++;
552 }
553
554 if(!pobj_c){
555 //クラスメンバ以外の場合のみ
556 //重複チェック
557
558 if(GetDeclareHash(temporary)){
559 SetError(15,temporary,nowLine);
560 return 0;
561 }
562 }
563
564 extern int SubNum;
565 SubNum++;
566
567
568 UserProc *pUserProc = new UserProc( temporary, kind, isMacro, isCdecl, isExport );
569 pUserProc->SetParentClass( pobj_c );
570
571 //ID
572 static int id_base=0;
573 pUserProc->id = (id_base++);
574
575 if(isExport){
576 pUserProc->Using();
577 }
578
579 // パラメータを解析
580 // ※第1パラメータにに指定するデータの例："( s As String ) As String"
581 pUserProc->SetParamsAndReturnType( buffer + i, nowLine, isStatic );
582
583
584 /////////////////////////////////
585 // ハッシュデータに追加
586 /////////////////////////////////
587
588 int key;
589 key=hash_default(pUserProc->GetName().c_str());
590
591 extern UserProc **ppSubHash;
592 if(ppSubHash[key]){
593 UserProc *psi2;
594 psi2=ppSubHash[key];
595 while(1){
596 if(pobj_c==psi2->GetParentClassPtr()){
597 //重複エラーチェックを行う
598 if( pUserProc->GetName() == psi2->GetName() ){
599 if( Parameter::Equals( psi2->Params(), pUserProc->Params() ) ){
600 SetError(15,pUserProc->GetName().c_str(),nowLine);
601 return 0;
602 }
603 }
604 }
605
606 if(psi2->pNextData==0) break;
607 psi2=psi2->pNextData;
608 }
609 psi2->pNextData=pUserProc;
610 }
611 else{
612 ppSubHash[key]=pUserProc;
613 }
614
615 return pUserProc;
616}
617
618void GetSubInfo(void){ //サブルーチン情報を取得
619 extern HANDLE hHeap;
620 extern char *basbuf;
621 int i,i2,i3;
622 char temporary[8192];
623
624 //Declare（DLL関数）情報を初期化
625 extern DllProc **ppDeclareHash;
626 ppDeclareHash=(DllProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DllProc *));
627
628 //サブルーチン（ユーザー定義）情報を初期化
629 extern UserProc **ppSubHash;
630 extern int SubNum;
631 ppSubHash=(UserProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(UserProc *));
632 SubNum=0;
633
634 //マクロ関数の名前リストを初期化
635 extern char **ppMacroNames;
636 extern int MacroNum;
637 ppMacroNames=(char **)HeapAlloc(hHeap,0,1);
638 MacroNum=0;
639
640 i=-1;
641 while(1){
642 i++;
643
644 if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_INTERFACE)){
645 /* Class ～ End Class
646 Interface ～ End Interface
647 を飛び越す */
648 i3=GetEndXXXCommand(basbuf[i+1]);
649 for(i+=2,i2=0;;i++,i2++){
650 if(basbuf[i]=='\0') break;
651 if(basbuf[i]==1&&basbuf[i+1]==(char)i3){
652 i++;
653 break;
654 }
655 }
656 if(basbuf[i]=='\0') break;
657 continue;
658 }
659
660 if(basbuf[i]==1&&basbuf[i+1]==ESC_DECLARE){
661 for(i+=2,i2=0;;i2++,i++){
662 if(basbuf[i]=='\n'){
663 temporary[i2]=0;
664 break;
665 }
666 temporary[i2]=basbuf[i];
667 if(basbuf[i]=='\0') break;
668 }
669 AddDeclareData(temporary,i);
670
671 continue;
672 }
673 if(basbuf[i]==1&&(basbuf[i+1]==ESC_SUB||basbuf[i+1]==ESC_FUNCTION||basbuf[i+1]==ESC_MACRO)){
674 for(i2=0;;i2++,i++){
675 if(IsCommandDelimitation(basbuf[i])){
676 temporary[i2]=0;
677 break;
678 }
679 temporary[i2]=basbuf[i];
680 if(basbuf[i]=='\0') break;
681 }
682 AddSubData(temporary,i,0,0);
683
684 continue;
685 }
686
687 //次の行
688 for(;;i++){
689 if(IsCommandDelimitation(basbuf[i])) break;
690 }
691 if(basbuf[i]=='\0') break;
692 }
693
694 ////////////
695 // 特殊関数
696 ////////////
697
698 sprintf(temporary,"%c%c_allrem()",1,ESC_SUB);
699 AddSubData(temporary,0,0,0);
700
701 sprintf(temporary,"%c%c_aullrem()",1,ESC_SUB);
702 AddSubData(temporary,0,0,0);
703
704 sprintf(temporary,"%c%c_allmul()",1,ESC_SUB);
705 AddSubData(temporary,0,0,0);
706
707 sprintf(temporary,"%c%c_alldiv()",1,ESC_SUB);
708 AddSubData(temporary,0,0,0);
709
710 sprintf(temporary,"%c%c_aulldiv()",1,ESC_SUB);
711 AddSubData(temporary,0,0,0);
712
713 sprintf(temporary,"%c%c_allshl()",1,ESC_SUB);
714 AddSubData(temporary,0,0,0);
715
716 sprintf(temporary,"%c%c_allshr()",1,ESC_SUB);
717 AddSubData(temporary,0,0,0);
718
719 sprintf(temporary,"%c%c_aullshr()",1,ESC_SUB);
720 AddSubData(temporary,0,0,0);
721
722 sprintf(temporary,"%c%c_System_InitStaticLocalVariables()",1,ESC_SUB);
723 AddSubData(temporary,0,0,0);
724}
725void Delete_si(UserProc *pUserProc){
726 if(pUserProc->pNextData) Delete_si(pUserProc->pNextData);
727 delete pUserProc;
728}
729void DeleteSubInfo(UserProc **ppSubHash,char **ppMacroNames,int MacroNum){ //サブルーチン情報のメモリ解放
730 int i;
731 for(i=0;i<MAX_HASH;i++){
732 if(!ppSubHash[i]) continue;
733
734 Delete_si(ppSubHash[i]);
735 }
736 HeapDefaultFree(ppSubHash);
737
738 //マクロの名前リスト
739 if(ppMacroNames){
740 for(i=0;i<MacroNum;i++){
741 HeapDefaultFree(ppMacroNames[i]);
742 }
743 HeapDefaultFree(ppMacroNames);
744 }
745}
746void Delete_di(DllProc *pDllProc){
747 if(pDllProc->pNextData) Delete_di(pDllProc->pNextData);
748
749 delete pDllProc;
750}
751void DeleteDeclareInfo(void){
752 //DLL情報を解放
753 extern DllProc **ppDeclareHash;
754 int i;
755 for(i=0;i<MAX_HASH;i++){
756 if(!ppDeclareHash[i]) continue;
757
758 Delete_di(ppDeclareHash[i]);
759 }
760 HeapDefaultFree(ppDeclareHash);
761}
762
763
764
765///////////////////////
766// 関数ポインタの管理
767///////////////////////
768
769int AddProcPtrInfo( const string &typeExpression, int nowLine ){
770 DWORD dwProcType = (DWORD)typeExpression[2];
771 const string &paramStr = typeExpression.substr( 3 );
772
773 Procedure::Kind kind = Procedure::Sub;
774 if( dwProcType == ESC_FUNCTION ){
775 kind = Procedure::Function;
776 }
777
778 ProcPointer *pProcPointer = new ProcPointer( kind );
779
780 //buffer[0]は'('となっている
781 pProcPointer->SetParamsAndReturnType( paramStr.c_str(), nowLine );
782
783 House::procPointers.push_back( pProcPointer );
784
785 return House::procPointers.size()-1;
786}
787void DeleteProcPtrInfo(void){
788 BOOST_FOREACH( ProcPointer *pProcPointer, House::procPointers ){
789 delete pProcPointer;
790 }
791
792 House::procPointers.clear();
793}
Note: See TracBrowser for help on using the repository browser.