source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Const.cpp@ 578

#include "stdafx.h"

using namespace ActiveBasic::Compiler;

void LexicalAnalyzer::AddConstEnum( Consts &consts, const NamespaceScopes &namespaceScopes, const char *buffer )
{
    extern int cp;
    int i=0,i2;

    if(!(buffer[i]==1&&buffer[i+1]==ESC_ENUM)) return;
    i+=2;

    //列挙体の名前を取得
    char temporary[VN_SIZE];
    for(i2=0;;i++,i2++){
        if(IsCommandDelimitation(buffer[i])){
            temporary[i2]=0;
            break;
        }
        if(!IsVariableChar(buffer[i])){
            compiler.errorMessenger.Output(1,NULL,i);
            break;
        }
        temporary[i2]=buffer[i];
    }

    if(buffer[i]=='\0'){
        compiler.errorMessenger.Output(22,"Enum",cp);
        return;
    }

    int NextValue=0;
    while(1){
        i++;

        if(buffer[i]==1&&buffer[i+1]==ESC_ENDENUM) break;

        for(i2=0;;i2++,i++){
            if(IsCommandDelimitation(buffer[i])){
                temporary[i2]=0;
                break;
            }
            if(buffer[i]=='='){
                temporary[i2]=0;
                break;
            }
            temporary[i2]=buffer[i];
        }
        if(temporary[0]=='\0'){
            if(buffer[i]=='\0'){
                compiler.errorMessenger.Output(22,"Enum",cp);
                break;
            }
            continue;
        }

        if(buffer[i]!='='){
            NextValue++;
        }
        else{
            char temp2[VN_SIZE];
            for(i++,i2=0;;i2++,i++){
                if(IsCommandDelimitation(buffer[i])){
                    temp2[i2]=0;
                    break;
                }
                temp2[i2]=buffer[i];
            }

            _int64 i64data;
            StaticCalculation(true, temp2,DEF_LONG,&i64data,Type());
            NextValue=(int)i64data;
        }

        //定数を追加
        consts.Add( namespaceScopes, temporary, NextValue);
    }
}

void LexicalAnalyzer::CollectConsts( const char *source, Consts &consts, ConstMacros &constMacros )
{
    ////////////////////////////////////////////
    // Const命令の情報を取得
    ////////////////////////////////////////////

    int i2;
    char temporary[1024];

    // 名前空間管理
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    for(int i=0;;i++){
        if( source[i] == '\0' ) break;

        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            namespaceScopes.push_back( temporary );

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                compiler.errorMessenger.Output(12, "End Namespace", i );
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }

        if( source[i] == 1 ){
            if(source[i]==1&&source[i+1]==ESC_CONST){
                i+=2;

                extern int cp;
                cp=i;   //エラー用


                if(source[i]==1&&source[i+1]==ESC_ENUM){
                    AddConstEnum( consts, namespaceScopes, source+i);
                    continue;
                }

                for(i2=0;;i++,i2++){
                    if(source[i]=='\"'){
                        temporary[i2]=source[i];
                        for(i++,i2++;;i++,i2++){
                            temporary[i2]=source[i];
                            if(source[i]=='\"') break;
                        }
                        continue;
                    }
                    if(IsCommandDelimitation(source[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=source[i];
                }

                //名前を取得
                char name[VN_SIZE];
                for(i2=0;;i2++){
                    if(temporary[i2]=='\0'){
                        compiler.errorMessenger.Output(10,"Const",cp);
                        return;
                    }
                    if(temporary[i2]=='='||temporary[i2]=='('){
                        name[i2]=0;
                        break;
                    }
                    name[i2]=temporary[i2];
                }

                //重複チェック
                if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExistDuplicationKeyName( name )
                    || compiler.GetObjectModule().meta.GetGlobalConsts().IsExistDuplicationKeyName( name ) )
                {
                    compiler.errorMessenger.Output(15,name,cp);
                    return;
                }

                if( temporary[i2] == '=' )
                {
                    // 定数
                    const char *expression = temporary + i2 + 1;
                    consts.Add( namespaceScopes, name, expression );
                }
                else
                {
                    // 定数マクロ
                    const char *params = temporary + i2;
                    constMacros.Add( namespaceScopes, name, params );
                }

                if(source[i]=='\0') break;
            }
            else{
                int result = JumpStatement( source, i );
                if( result == -1 ){
                    //エラー
                    return;
                }
                else if( result == 1 ){
                    //ジャンプした場合
                    i--;
                }
            }
        }
    }

    // イテレータを初期化
    compiler.GetObjectModule().meta.GetGlobalConsts().Iterator_Init();
    compiler.GetObjectModule().meta.GetGlobalConstMacros().Iterator_Init();
}

bool LexicalAnalyzer::ConstMacroToExpression( const ConstMacro &constMacro, const char *parameterStr, char *dest )
{
    extern HANDLE hHeap;
    int i2,i3,i4,num;
    char temporary[VN_SIZE];
    char *pParms[MAX_PARMS];
    num=0;
    i2=0;
    while(1){
        i2=GetOneParameter(parameterStr,i2,temporary);

        pParms[num]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
        lstrcpy(pParms[num],temporary);

        num++;
        if(parameterStr[i2]=='\0') break;
    }
    if( num != constMacro.GetParameters().size() ){
        extern int cp;
        for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
        compiler.errorMessenger.Output(10,constMacro.GetName().c_str(),cp);
        lstrcpy(dest,"0");
        return true;
    }

    i2=0;
    i4=0;
    while(1){

        //数式内の項を取得
        for(i3=0;;i2++,i3++){
            if(!IsVariableChar( constMacro.GetExpression()[i2] )){
                temporary[i3]=0;
                break;
            }
            temporary[i3] = constMacro.GetExpression()[i2];
        }

        //パラメータと照合する
        for( i3=0; i3<(int)constMacro.GetParameters().size(); i3++ ){
            if( constMacro.GetParameters()[i3] == temporary ) break;
        }

        if( i3 == (int)constMacro.GetParameters().size() ){
            //パラメータでないとき
            lstrcpy(dest+i4,temporary);
            i4+=lstrlen(temporary);
        }
        else{
            //パラメータのとき
            lstrcpy(dest+i4,pParms[i3]);
            i4+=lstrlen(pParms[i3]);
        }

        //演算子をコピー
        for(;;i2++,i4++){
            if( constMacro.GetExpression()[i2] == 1 ){
                dest[i4++] = constMacro.GetExpression()[i2++];
                dest[i4] = constMacro.GetExpression()[i2];
                continue;
            }
            if(IsVariableTopChar( constMacro.GetExpression()[i2] )) break;
            dest[i4] = constMacro.GetExpression()[i2];
            if( constMacro.GetExpression()[i2] == '\0' ) break;
        }

        if( constMacro.GetExpression()[i2] == '\0' ) break;
    }

    for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);

    return true;
}