source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/Procedure.cpp @ 571

Last change on this file since 571 was 571, checked in by dai_9181, 15 years ago

・LexicalAnalyzer::AnalyzeParameterの第二パラメータをstringからStringsに変更した。
・UserProc::SetParamsAndReturnTypeメソッド内で行っているパラメータ解析処理をLexicalAnalyzer::AnalyzeParameterメソッドを使用したコードに書き直した。
File size: 17.6 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4#include <Procedure.h>
5
6#include "../common.h"
7#ifdef _AMD64_
8#include "../../compiler_x64/opcode.h"
9#else
10#include "../../compiler_x86/opcode.h"
11#endif
12
13using namespace ActiveBasic::Compiler;
14
15
16bool UserProc::IsEqualForOverride( const Types &actualTypeParametersForThisProc, const UserProc *pUserProc ) const
17{
18    if( this->GetName() == pUserProc->GetName()                     // 名前空間及び名前が等しい
19        && this->Params().Equals( actualTypeParametersForThisProc, pUserProc->Params() ) )          // パラメータが等しい
20    {
21        if( this->returnType.Equals( pUserProc->returnType ) )
22        {
23            // 戻り値が等しい
24            return true;
25        }
26        else if( this->returnType.IsCovariant( pUserProc->returnType ) )
27        {
28            // 戻り値が共変
29            return true;
30        }
31        else if( this->returnType.IsTypeParameter() )
32        {
33            // 型パラメータだったとき
34
35            if( actualTypeParametersForThisProc[this->returnType.GetFormalTypeIndex()].Equals( pUserProc->returnType ) )
36            {
37                // 戻り値が等しい
38                return true;
39            }
40            else if( actualTypeParametersForThisProc[this->returnType.GetFormalTypeIndex()].IsCovariant( pUserProc->returnType ) )
41            {
42                // 戻り値が共変
43                return true;
44            }
45        }
46    }
47    return false;
48}
49   
50
51std::string UserProc::GetFullName() const
52{
53    if( HasParentClass() ){
54        return GetParentClass().GetName() + "." + GetName();
55    }
56
57    return GetName();
58}
59bool UserProc::IsCastOperator() const
60{
61    if( GetName()[0] == 1 && GetName()[1] == ESC_OPERATOR && GetName()[2] == CALC_AS )
62    {
63        return true;
64    }
65    return false;
66}
67const NamespaceScopes &UserProc::GetNamespaceScopes() const
68{
69    if( HasParentClass() ){
70        return GetParentClassPtr()->GetNamespaceScopes();
71    }
72    return Symbol::GetNamespaceScopes();
73}
74const NamespaceScopesCollection &UserProc::GetImportedNamespaces() const
75{
76    if( pParentClass )
77    {
78        return pParentClass->GetImportedNamespaces();
79    }
80    return importedNamespaces;
81}
82bool UserProc::IsVirtual() const
83{
84    if( pMethod == NULL ){
85        return false;
86    }
87    return ( pMethod->IsVirtual() != 0 );
88}
89const CMethod &UserProc::GetMethod() const
90{
91    if( !HasParentClass() )
92    {
93        Jenga::Throw( "グローバル関数に対してUserProc::GetMethodメソッドが呼ばれた" );
94    }
95    return *pMethod;
96}
97
98bool UserProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic ){
99    int i = 0;
100
101    //ソースコードの位置
102    this->codePos = nowLine;
103
104    //パラメータ
105    if(sourceOfParams[i]!='('){
106        compiler.errorMessenger.Output(1,NULL,nowLine);
107        return false;
108    }
109    if(sourceOfParams[i + 1]!=')'&& this->pParentClass ){
110        //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
111        if(this->GetName()[0]=='~'){
112            compiler.errorMessenger.Output(114,NULL,nowLine);
113            return false;
114        }
115    }
116
117    // カッコ内のパラメータ文字列を取得
118    char parametersStr1[8192];
119    char parametersStr2[8192] = "";
120    i += GetStringInPare( parametersStr1, sourceOfParams + i, true );
121    if( sourceOfParams[i] == '(' )
122    {
123        i += GetStringInPare( parametersStr2, sourceOfParams + i, true );
124    }
125
126    // 戻り値文字列を取得
127    char returnTypeStr[VN_SIZE] = "";
128    if( sourceOfParams[i] )
129    {
130        if( sourceOfParams[i] == 1 && sourceOfParams[i+1] == ESC_AS )
131        {
132            if( !this->IsFunction() ){
133                // Sub/Macroの場合
134                compiler.errorMessenger.Output(38,this->GetName(),nowLine);
135            }
136
137            lstrcpy( returnTypeStr, sourceOfParams + i + 2 );
138        }
139        else
140        {
141            compiler.errorMessenger.Output(1,NULL,nowLine);
142            return false;
143        }
144    }
145
146    Jenga::Common::Strings parameters;
147
148    // パラメータ
149    SplitParameter( parametersStr1, parameters );
150    ActiveBasic::Compiler::LexicalAnalyzer::AnalyzeParameter( params, parameters, nowLine );
151
152    // 省略可能パラメータ（古い仕様。非推奨）
153    this->secondParmNum = (int)this->params.size();
154    SplitParameter( parametersStr2, parameters );
155    ActiveBasic::Compiler::LexicalAnalyzer::AnalyzeParameter( params, parameters, nowLine );
156
157
158    if(returnTypeStr[0]){
159        ///////////////////
160        // 戻り値を取得
161        ///////////////////
162
163        if( !this->IsFunction() ){
164            // Sub/Macroの場合
165            compiler.errorMessenger.Output(38,this->GetName(),nowLine);
166        }
167
168        if( this->pParentClass ){
169            if( this->GetName() == this->pParentClass->GetName() ||
170                this->GetName()[0]=='~'){
171                //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
172                compiler.errorMessenger.Output(115,NULL,nowLine);
173            }
174        }
175
176        compiler.StringToType( returnTypeStr, this->returnType );
177        if( this->returnType.IsNull() )
178        {
179            compiler.errorMessenger.Output(3,returnTypeStr,nowLine);
180        }
181    }
182    else{
183        if( this->IsFunction() )
184        {
185            // Function定義なのに、戻り値の型がセットされていない
186            compiler.errorMessenger.Output(-104,this->GetName().c_str(),nowLine);
187
188            this->returnType.SetBasicType( DEF_DOUBLE );
189        }
190        else
191        {
192            //戻り値なしのSub定義
193            this->returnType.SetNull();
194        }
195    }
196
197    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する場合がある）
198
199    if( this->pParentClass && isStatic == false ){
200        //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
201        std::string name = "_System_LocalThis";
202        Type type( DEF_PTR_VOID );
203        this->realParams.push_back( new Parameter( name, type ) );
204    }
205
206    if( this->returnType.IsStruct() ){
207        //構造体を戻り値として持つ場合
208        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
209
210        std::string name = this->GetName();
211        if(name[0]==1&&name[1]==ESC_OPERATOR){
212            name="_System_ReturnValue";
213        }
214        Type type( DEF_STRUCT, this->returnType.GetIndex() );
215        this->realParams.push_back( new Parameter( name, type, true ) );
216    }
217
218    //パラメータをコピー
219    BOOST_FOREACH( Parameter *pParam, params ){
220        this->realParams.push_back( new Parameter( *pParam ) );
221    }
222
223    return true;
224}
225
226const UserProc *UserProc::pGlobalProc = NULL;
227
228
229bool UserProcs::Insert( UserProc *pUserProc, int nowLine )
230{
231    /////////////////////////////////
232    // ハッシュデータに追加
233    /////////////////////////////////
234
235    if( !Put( pUserProc ) )
236    {
237        // 重複しているため、失敗
238        compiler.errorMessenger.Output(15,pUserProc->GetName().c_str(),nowLine);
239        return false;
240    }
241
242    return true;
243}
244
245void UserProcs::EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs )
246{
247    ///////////////////////////
248    // グローバル関数を検索
249    ///////////////////////////
250
251    // ハッシュ値を取得
252    UserProc *pUserProc = GetHashArrayElement( simpleName );
253    while(pUserProc){
254        if( pUserProc->IsGlobalProcedure() ){
255            if( pUserProc->IsEqualSymbol( LexicalAnalyzer::FullNameToSymbol( localName ) ) ){
256                subs.push_back( pUserProc );
257            }
258        }
259
260        pUserProc=pUserProc->GetChainNext();
261    }
262}
263
264bool DllProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
265    int i = 0;
266    int i2,i3,sw;
267    char temporary[8192],temp2[VN_SIZE];
268
269    //ソースコードの位置
270    this->codePos = nowLine;
271
272    //パラメータ
273    if(sourceOfParams[i]!='('){
274        compiler.errorMessenger.Output(1,NULL,nowLine);
275        return 0;
276    }
277    i++;
278
279    while(1){
280        if(sourceOfParams[i]==')') break;
281
282        //ByRef
283        bool isRef;
284        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
285            isRef = false;
286            i+=2;
287        }
288        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
289            isRef = true;
290            i+=2;
291        }
292        else isRef = false;
293
294        //パラメータ名
295        bool isArray = false;
296        Subscripts subscripts;
297        char name[VN_SIZE];
298        sw=0;
299        for(i2=0;;i++,i2++){
300            if(sourceOfParams[i]=='('){
301                if(!sw) sw=1;
302
303                i3=GetStringInPare(name+i2,sourceOfParams+i);
304                i2+=i3-1;
305                i+=i3-1;
306                continue;
307            }
308            if(sourceOfParams[i]=='['){
309                if(!sw) sw=1;
310
311                i3=GetStringInBracket(name+i2,sourceOfParams+i);
312                i2+=i3-1;
313                i+=i3-1;
314                continue;
315            }
316            if(!IsVariableChar(sourceOfParams[i])){
317                name[i2]=0;
318                break;
319            }
320            name[i2]=sourceOfParams[i];
321        }
322        if(sw){
323            //配列パラメータ
324            if( isRef == false ) compiler.errorMessenger.Output(29,NULL,nowLine);
325            isArray = true;
326
327            if((name[i2-2]=='('&&name[i2-1]==')')||
328                (name[i2-2]=='['&&name[i2-1]==']'))
329            {
330                subscripts.push_back( LONG_MAX );
331
332                name[i2-2]=0;
333            }
334            else{
335                GetArrange(name,temp2,subscripts);
336                lstrcpy(name,temp2);
337            }
338
339            i2=lstrlen(name);
340        }
341
342        //型
343        Type type( DEF_NON );
344        if(lstrcmp(name,"...")==0) type.SetBasicType( DEF_ELLIPSE );
345        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
346            i+=2;
347
348            i2=0;
349            while(sourceOfParams[i]=='*'){
350                temporary[i2]=sourceOfParams[i];
351                i++;
352                i2++;
353            }
354            for(;;i++,i2++){
355                if(!IsVariableChar(sourceOfParams[i])){
356                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
357                        temporary[i2++]=sourceOfParams[i++];
358                        temporary[i2]=sourceOfParams[i];
359                        continue;
360                    }
361                    temporary[i2]=0;
362                    break;
363                }
364                temporary[i2]=sourceOfParams[i];
365            }
366
367            compiler.StringToType( temporary, type );
368
369            if( type.IsNull() ){
370                compiler.errorMessenger.Output(3,temporary,nowLine);
371                type.SetBasicType( DEF_PTR_VOID );
372            }
373        }
374        else{
375            type.SetBasicType( Type::GetBasicTypeFromSimpleName(temporary) );
376            compiler.errorMessenger.Output(-103,temporary,nowLine);
377        }
378
379        Parameter *pParam = new Parameter( name, type, isRef );
380        if( isArray ){
381            pParam->SetArray( subscripts );
382        }
383
384        //パラメータを追加
385        this->params.push_back( pParam );
386
387        if(sourceOfParams[i]==','){
388            i++;
389            continue;
390        }
391        else if(sourceOfParams[i]==')') continue;
392        else{
393            compiler.errorMessenger.Output(1,NULL,nowLine);
394            break;
395        }
396    }
397    i++;
398
399    if(sourceOfParams[i]){
400        ///////////////////
401        // 戻り値を取得
402        ///////////////////
403
404        i2=lstrlen(sourceOfParams)-2;
405
406        int sw_as=0;
407        for(;i2>0;i2--){
408            if(sourceOfParams[i2]==')') break;
409
410            if(sourceOfParams[i2]==1&&sourceOfParams[i2+1]==ESC_AS){
411                i2+=2;
412                i3=0;
413                while(sourceOfParams[i2]=='*') temporary[i3++]=sourceOfParams[i2++];
414                for(;;i2++,i3++){
415                    if(!IsVariableChar(sourceOfParams[i2])){
416                        temporary[i3]=0;
417                        break;
418                    }
419                    temporary[i3]=sourceOfParams[i2];
420                }
421                compiler.StringToType( temporary, this->returnType );
422                if( this->returnType.IsNull() ) compiler.errorMessenger.Output(3,temporary,nowLine);
423
424                sw_as=1;
425                break;
426            }
427        }
428    }
429    else{
430        //戻り値なしのSub定義
431        this->returnType.SetNull();
432    }
433
434    return true;
435}
436
437void DllProcs::Add(const NamespaceScopes &namespaceScopes, char *buffer,int nowLine){
438    int i2;
439
440    int i=0;
441
442    //Sub/Function
443    Procedure::Kind kind = Procedure::Sub;
444    if(buffer[i]==ESC_SUB){
445    }
446    else if(buffer[i]==ESC_FUNCTION){
447        kind = Procedure::Function;
448    }
449    else{
450        compiler.errorMessenger.Output(1,NULL,nowLine);
451        return;
452    }
453    i++;
454
455    //プロシージャ名
456    char procName[VN_SIZE];
457    bool isCdecl = false;
458    for(i2=0;;i++,i2++){
459        if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
460            isCdecl = true;
461
462            i+=2;
463            procName[i2]=0;
464            break;
465        }
466        if(buffer[i]==','){
467            procName[i2]=0;
468            break;
469        }
470        if(buffer[i]=='\0'){
471            compiler.errorMessenger.Output(1,NULL,nowLine);
472            return;
473        }
474        procName[i2]=buffer[i];
475    }
476    i++;
477
478    //ユーザー定義関数との重複チェック
479    if(GetSubHash(procName)){
480        compiler.errorMessenger.Output(15,procName,nowLine);
481        return;
482    }
483
484
485    //ライブラリ
486    char dllFileName[MAX_PATH];
487    i = GetOneParameter( buffer, i, dllFileName );
488    Type resultType;
489    _int64 i64data;
490    if( !StaticCalculation( true, dllFileName, 0, &i64data, resultType ) ){
491        return;
492    }
493    if( resultType.GetBasicType() != typeOfPtrChar ){
494        compiler.errorMessenger.Output(1,NULL,nowLine);
495        return;
496    }
497    lstrcpy( dllFileName, (char *)i64data );
498    CharUpper(dllFileName);
499    if(!strstr(dllFileName,".")){
500        lstrcat(dllFileName,".DLL");
501        if(lstrlen(dllFileName)>=16){
502            compiler.errorMessenger.Output(7,NULL,nowLine);
503            return;
504        }
505    }
506
507    //エイリアス
508    char alias[VN_SIZE];
509    i = GetOneParameter( buffer, i, alias );
510    if( alias[0] ){
511        if( !StaticCalculation( true, alias, 0, &i64data, resultType ) ){
512            return;
513        }
514        if( resultType.GetBasicType() != typeOfPtrChar ){
515            compiler.errorMessenger.Output(1,NULL,nowLine);
516            return;
517        }
518        lstrcpy( alias, (char *)i64data );
519    }
520    else{
521        //省略されたときは関数名
522        lstrcpy( alias, procName );
523    }
524
525
526    // オブジェクトを生成
527    DllProc *pDllProc = new DllProc( namespaceScopes, procName, kind, isCdecl, dllFileName, alias );
528
529    // パラメータを解析
530    // ※第1パラメータにに指定するデータの例："( s As String ) As String"
531    pDllProc->SetParamsAndReturnType( buffer + i, nowLine );
532
533    // パラメータのエラーチェック
534    BOOST_FOREACH( const Parameter *pParam, pDllProc->Params() ){
535        if( pParam->IsObject() ){
536            compiler.errorMessenger.Output(25,pParam->GetVarName(),nowLine);
537        }
538        if( !pParam->IsRef() ){
539            if( pParam->IsStruct() ){
540                compiler.errorMessenger.Output(28,pParam->GetVarName(),nowLine);
541            }
542        }
543    }
544
545    //戻り値のエラーチェック
546    if( pDllProc->IsFunction() ){
547        // Function定義
548
549        if( pDllProc->ReturnType().IsObject() ){
550            // DLL関数ではオブジェクトを戻り値にできない
551            compiler.errorMessenger.Output(40,pDllProc->GetName(),nowLine);
552        }
553    }
554
555    // ハッシュマップに追加
556    this->Put( pDllProc );
557}
558
559bool ProcPointer::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
560    int i = 0;
561    int i2,i3,sw;
562    char temporary[8192],temp2[VN_SIZE];
563
564    //ソースコードの位置
565    this->codePos = nowLine;
566
567    //パラメータ
568    if(sourceOfParams[i]!='('){
569        compiler.errorMessenger.Output(1,NULL,nowLine);
570        return 0;
571    }
572    i++;
573    while(1){
574        if(sourceOfParams[i]==')') break;
575
576        //ByRef
577        bool isRef;
578        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
579            isRef = false;
580            i+=2;
581        }
582        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
583            isRef = true;
584            i+=2;
585        }
586        else isRef = false;
587
588        //パラメータ名
589        bool isArray = false;
590        Subscripts subscripts;
591        char name[VN_SIZE];
592        sw=0;
593        for(i2=0;;i++,i2++){
594            if(sourceOfParams[i]=='('){
595                if(!sw) sw=1;
596
597                i3=GetStringInPare(name+i2,sourceOfParams+i);
598                i2+=i3-1;
599                i+=i3-1;
600                continue;
601            }
602            if(sourceOfParams[i]=='['){
603                if(!sw) sw=1;
604
605                i3=GetStringInBracket(name+i2,sourceOfParams+i);
606                i2+=i3-1;
607                i+=i3-1;
608                continue;
609            }
610            if(!IsVariableChar(sourceOfParams[i])){
611                name[i2]=0;
612                break;
613            }
614            name[i2]=sourceOfParams[i];
615        }
616        if(sw){
617            //配列パラメータ
618            if( isRef == false ) compiler.errorMessenger.Output(29,NULL,nowLine);
619            isArray = true;
620
621            if((name[i2-2]=='('&&name[i2-1]==')')||
622                (name[i2-2]=='['&&name[i2-1]==']'))
623            {
624                subscripts.push_back( LONG_MAX );
625
626                name[i2-2]=0;
627            }
628            else{
629                GetArrange(name,temp2,subscripts);
630                lstrcpy(name,temp2);
631            }
632
633            i2=lstrlen(name);
634        }
635
636        //型
637        Type type( DEF_NON );
638        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
639            i+=2;
640
641            i2=0;
642            while(sourceOfParams[i]=='*'){
643                temporary[i2]=sourceOfParams[i];
644                i++;
645                i2++;
646            }
647            for(;;i++,i2++){
648                if(!IsVariableChar(sourceOfParams[i])){
649                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
650                        temporary[i2++]=sourceOfParams[i++];
651                        temporary[i2]=sourceOfParams[i];
652                        continue;
653                    }
654                    temporary[i2]=0;
655                    break;
656                }
657                temporary[i2]=sourceOfParams[i];
658            }
659
660            compiler.StringToType( temporary, type );
661
662            if( type.IsNull() ){
663                compiler.errorMessenger.Output(3,temporary,nowLine);
664                type.SetBasicType( DEF_PTR_VOID );
665            }
666        }
667        else{
668            type.SetBasicType( Type::GetBasicTypeFromSimpleName(temporary) );
669            compiler.errorMessenger.Output(-103,temporary,nowLine);
670        }
671
672        Parameter *pParam = new Parameter( name, type, isRef );
673        if( isArray ){
674            pParam->SetArray( subscripts );
675        }
676
677        //パラメータを追加
678        this->params.push_back( pParam );
679
680        if(sourceOfParams[i]==','){
681            i++;
682            continue;
683        }
684        else if(sourceOfParams[i]==')') continue;
685        else{
686            compiler.errorMessenger.Output(1,NULL,nowLine);
687            break;
688        }
689    }
690    i++;
691
692    if(sourceOfParams[i]){
693        ///////////////////
694        // 戻り値を取得
695        ///////////////////
696
697        i2=lstrlen(sourceOfParams)-2;
698
699        int sw_as=0;
700        for(;i2>0;i2--){
701            if(sourceOfParams[i2]==')') break;
702
703            if(sourceOfParams[i2]==1&&sourceOfParams[i2+1]==ESC_AS){
704                i2+=2;
705                i3=0;
706                while(sourceOfParams[i2]=='*') temporary[i3++]=sourceOfParams[i2++];
707                for(;;i2++,i3++){
708                    if(!IsVariableChar(sourceOfParams[i2])){
709                        temporary[i3]=0;
710                        break;
711                    }
712                    temporary[i3]=sourceOfParams[i2];
713                }
714                compiler.StringToType( temporary, this->returnType );
715                if( this->returnType.IsNull() ) compiler.errorMessenger.Output(3,temporary,nowLine);
716
717                sw_as=1;
718                break;
719            }
720        }
721    }
722    else{
723        //戻り値なしのSub定義
724        this->returnType.SetNull();
725    }
726
727    //戻り値のエラーチェック
728    if( IsFunction() ){
729        // Function定義
730
731        if( this->ReturnType().IsNull() ){
732            // 戻り値がない
733            compiler.errorMessenger.Output(26,this->GetName(),nowLine);
734        }
735    }
736    else{
737        if( !this->ReturnType().IsNull() ){
738            // Sub定義なのに、戻り値がある
739            compiler.errorMessenger.Output(38,this->GetName(),nowLine);
740        }
741    }
742
743    return true;
744}
745
746int ProcPointers::Add( const std::string &typeExpression )
747{
748    DWORD dwProcType = (DWORD)typeExpression[2];
749    const std::string &paramStr = typeExpression.substr( 3 );
750
751    Procedure::Kind kind = Procedure::Sub;
752    if( dwProcType == ESC_FUNCTION ){
753        kind = Procedure::Function;
754    }
755
756    ProcPointer *pProcPointer = new ProcPointer( kind );
757
758    //buffer[0]は'('となっている
759    extern int cp;
760    pProcPointer->SetParamsAndReturnType( paramStr.c_str(), cp );
761
762    this->push_back( pProcPointer );
763
764    return (int)this->size()-1;
765}
766
767void ProcPointers::Clear()
768{
769    ProcPointers &procPointers = *this;
770    BOOST_FOREACH( ProcPointer *pProcPointer, procPointers ){
771        delete pProcPointer;
772    }
773    this->clear();
774}
Note: See TracBrowser for help on using the repository browser.