Changeset 708 in dev

Timestamp:

Jul 26, 2008, 7:27:20 AM (16 years ago)

Author:

dai_9181

Message:

• #184への対応。ByRef引数を持つデリゲートを宣言するとコンパイルできないバグを修正。
• オーバーロード用のパラメータ比較にByRef/ByValの相違を考慮するようにした。

Location:

trunk/ab5.0/abdev

Files:

• BasicCompiler_Common/ParamImpl.cpp (modified) (3 diffs)
• BasicCompiler_Common/include/LexicalAnalyzer.h (modified) (1 diff)
• BasicCompiler_Common/src/LexicalAnalyzer_Delegate.cpp (modified) (1 diff)
• BasicCompiler_Common/src/LexicalAnalyzer_Procedure.cpp (modified) (1 diff)
• ab_common/src/Lexical/Parameter.cpp (modified) (2 diffs)

trunk/ab5.0/abdev/BasicCompiler_Common/ParamImpl.cpp

@@ -309 +309 @@
         lstrcpy(Parms[ParmsNum],param.GetInitValue().c_str() );
         ParmsNum++;
+
+        types.push_back( Type() );
     }
 }
@@ -334 +336 @@
 
         //省略パラメータに "0" を指定する
-        for(;ParmsNum < (int)params.size();ParmsNum++){
+        while( ParmsNum < (int)params.size() )
+        {
             extern HANDLE hHeap;
             char temporary[64];
@@ -341 +344 @@
             Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
             lstrcpy(Parms[ParmsNum],temporary);
+
+            ParmsNum++;
+
+            types.push_back( Type() );
         }
     }

trunk/ab5.0/abdev/BasicCompiler_Common/include/LexicalAnalyzer.h

@@ -48 +48 @@
 
     // グローバルプロシージャを収集する
+    static bool ExtractParameterVarNames( const char *sourceOfParams, Jenga::Common::Strings &paramVarNames, int nowLine );
     static bool AnalyzeParameter( Parameters &params, const Jenga::Common::Strings &parameterStrings, int nowLine );
     static bool SetParamsAndReturnTypeForUserProc( UserProc &userProc, const char *sourceOfParams, int nowLine, bool isStatic );

trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Delegate.cpp

@@ -201 +201 @@
         }
 
-        values.insert( std::map<std::string,std::string>::value_type( "#params#", dg.GetParamStr() ) );
+        // 呼び出し側の実引数文字列を作成
+        Jenga::Common::Strings paramVarNames;
+        LexicalAnalyzer::ExtractParameterVarNames( dg.GetParamStr().c_str(), paramVarNames, dg.GetSourceIndex() );
+        std::string tempParamStrForCall;
+        BOOST_FOREACH( const std::string &varName, paramVarNames )
+        {
+            if( !tempParamStrForCall.empty() )
+            {
+                tempParamStrForCall += ",";
+            }
+            tempParamStrForCall += varName;
+        }
+        values.insert( std::map<std::string,std::string>::value_type( "#params#", tempParamStrForCall ) );
 
         destSource += sourceTemplate.GetResult( values );

trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Procedure.cpp

@@ -2 +2 @@
 
 using namespace ActiveBasic::Compiler;
+
+bool LexicalAnalyzer::ExtractParameterVarNames( const char *sourceOfParams, Jenga::Common::Strings &paramVarNames, int nowLine )
+{
+    int i = 0;
+    int i2,i3,sw;
+    char temporary[8192],temp2[VN_SIZE];
+
+    while(1){
+        if(sourceOfParams[i]=='\0') break;
+
+        //ByRef
+        bool isRef;
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
+            isRef = false;
+            i+=2;
+        }
+        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
+            isRef = true;
+            i+=2;
+        }
+        else isRef = false;
+
+        //パラメータ名
+        bool isArray = false;
+        Subscripts subscripts;
+        char name[VN_SIZE];
+        sw=0;
+        for(i2=0;;i++,i2++){
+            if(sourceOfParams[i]=='('){
+                if(!sw) sw=1;
+
+                i3=GetStringInPare(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(sourceOfParams[i]=='['){
+                if(!sw) sw=1;
+
+                i3=GetStringInBracket(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(!IsVariableChar(sourceOfParams[i])){
+                name[i2]=0;
+                break;
+            }
+            name[i2]=sourceOfParams[i];
+        }
+        if(sw){
+            //配列パラメータ
+            if( isRef == false ) compiler.errorMessenger.Output(29,NULL,nowLine);
+            isArray = true;
+
+            if((name[i2-2]=='('&&name[i2-1]==')')||
+                (name[i2-2]=='['&&name[i2-1]==']'))
+            {
+                subscripts.push_back( LONG_MAX );
+
+                name[i2-2]=0;
+            }
+            else{
+                GetArrange(name,temp2,subscripts);
+                lstrcpy(name,temp2);
+            }
+
+            i2=lstrlen(name);
+        }
+
+        paramVarNames.push_back( name );
+
+        //型
+        Type type( DEF_NON );
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS)
+        {
+            i+=2;
+
+            i2=0;
+            while(sourceOfParams[i]=='*'){
+                temporary[i2]=sourceOfParams[i];
+                i++;
+                i2++;
+            }
+            for(;;i++,i2++){
+                if(!IsVariableChar(sourceOfParams[i], true)){
+                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
+                        temporary[i2++]=sourceOfParams[i++];
+                        temporary[i2]=sourceOfParams[i];
+                        continue;
+                    }
+                    temporary[i2]=0;
+                    break;
+                }
+                temporary[i2]=sourceOfParams[i];
+            }
+        }
+
+        if(sourceOfParams[i]==','){
+            i++;
+            continue;
+        }
+        else if(sourceOfParams[i]=='\0') break;
+        else{
+            compiler.errorMessenger.Output(1,NULL,nowLine);
+            break;
+        }
+    }
+
+    return true;
+}
 
 bool LexicalAnalyzer::AnalyzeParameter( Parameters &params, const Jenga::Common::Strings &parameterStrings, int nowLine )

trunk/ab5.0/abdev/ab_common/src/Lexical/Parameter.cpp

@@ -40 +40 @@
 bool Parameter::Equals( const Parameter &param, bool isContravariant ) const
 {
-    if( Type::Equals( param ) )
+    if( Type::Equals( param ) && this->isRef == param.isRef )
     {
         return true;
@@ -64 +64 @@
     {
         // 反変引数を許可する
-        if( this->IsContravariant( param ) )
+        if( this->IsContravariant( param ) && this->isRef == param.isRef )
         {
             // 反変引数だったとき