source: dev/trunk/abdev/BasicCompiler_Common/Subroutine.cpp@ 195

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