Changeset 75 in dev for BasicCompiler_Common/Variable.cpp


Ignore:
Timestamp:
Mar 20, 2007, 4:36:16 AM (17 years ago)
Author:
dai_9181
Message:

TYPEINFO→Typeへのリファクタリングを実施。64bitはほぼ完了。32bitが全般的に未完成。

File:
1 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler_Common/Variable.cpp

    r73 r75  
    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 
    9 BOOL IsVariableTopChar(char c){
    10     if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||c=='_') return 1;
    11     return 0;
    12 }
    13 BOOL IsVariableChar(char c){
    14     if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9')||
    15         c=='%'||c=='!'||c=='#'||c=='$'||
    16         c=='_'||c=='.') return 1;
    17     return 0;
    18 }
    19 BOOL IsPtrType(int type){
    20     if(type==-1) return 0;
    21 
    22     if(PTR_LEVEL(type)||type==DEF_PTR_VOID||type==DEF_PTR_PROC||
    23         (type&FLAG_PTR) ) return 1;
    24 
    25     return 0;
    26 }
    27 BOOL IsSignedType(int type){
    28     switch(type){
    29         case DEF_SBYTE:
    30         case DEF_INTEGER:
    31         case DEF_LONG:
    32         case DEF_INT64:
    33         case DEF_SINGLE:
    34         case DEF_DOUBLE:
    35         case DEF_CHAR:
    36             return 1;
    37         default:
    38             break;
    39     }
    40     return 0;
    41 }
    42 BOOL IsNaturalWholeNumberType(int type){
    43     switch(type){
    44         case DEF_SBYTE:
    45         case DEF_BYTE:
    46         case DEF_INTEGER:
    47         case DEF_WORD:
    48         case DEF_LONG:
    49         case DEF_DWORD:
    50         case DEF_INT64:
    51         case DEF_QWORD:
    52         case DEF_CHAR:
    53             return 1;
    54         default:
    55             break;
    56     }
    57     return 0;
    58 }
    59 BOOL IsWholeNumberType(int type){
    60     return (
    61         IsNaturalWholeNumberType(type)
    62         || IsPtrType(type)
    63         || type == DEF_BOOLEAN
    64         );
    65 }
    66 BOOL IsRealNumberType(int type){
    67     switch(type){
    68         case DEF_DOUBLE:
    69         case DEF_SINGLE:
    70             return 1;
    71         default:
    72             break;
    73     }
    74     return 0;
    75 }
    76 BOOL Is64Type(int type){
    77     switch(type){
    78         case DEF_INT64:
    79         case DEF_QWORD:
    80             return 1;
    81         default:
    82             break;
    83     }
    84 #ifdef _AMD64_
    85     return IsPtrType(type);
    86 #else
    87     return 0;
    88 #endif
    89 }
    90 int GetSignedType(int type){
    91     switch(type){
    92         case DEF_BYTE:
    93             return DEF_SBYTE;
    94         case DEF_WORD:
    95             return DEF_INTEGER;
    96         case DEF_DWORD:
    97             return DEF_LONG;
    98         case DEF_QWORD:
    99             return DEF_INT64;
    100         default:
    101             break;
    102     }
    103 #ifdef _AMD64_
    104     if(IsPtrType(type)) return DEF_INT64;
    105 #else
    106     if(IsPtrType(type)) return DEF_LONG;
    107 #endif
    108     return type;
    109 }
    110 int GetUnsignedType(int type){
    111     switch(type){
    112         case DEF_SBYTE:
    113             return DEF_BYTE;
    114         case DEF_INTEGER:
    115             return DEF_WORD;
    116         case DEF_LONG:
    117             return DEF_DWORD;
    118         case DEF_INT64:
    119             return DEF_QWORD;
    120         case DEF_CHAR:
    121             if( isUnicode ) return DEF_WORD;
    122             return DEF_BYTE;
    123     }
    124     return type;
    125 }
    126 int GetTypeSize(int type,LONG_PTR lpIndex){
    127     if(type==DEF_LONG){
    128         if(lpIndex==LITERAL_NULL||lpIndex==LITERAL_M128_0||lpIndex==LITERAL_0_255)
    129             return sizeof(BYTE);
    130         else if(lpIndex==LITERAL_M32768_0||lpIndex==LITERAL_0_65535)
    131             return sizeof(WORD);
    132 
    133         return sizeof(DWORD);
    134     }
    135 
    136     //整数型
    137     if(type==DEF_INT64||type==DEF_QWORD)
    138         return sizeof(_int64);
    139     else if(type==DEF_LONG||type==DEF_DWORD)
    140         return sizeof(DWORD);
    141     else if(type==DEF_INTEGER||type==DEF_WORD)
    142         return sizeof(WORD);
    143     else if(type==DEF_SBYTE||type==DEF_BYTE || type == DEF_BOOLEAN)
    144         return sizeof(BYTE);
    145 
    146     //実数型
    147     else if(type==DEF_DOUBLE)       return sizeof(double);
    148     else if(type==DEF_SINGLE)       return sizeof(float);
    149 
    150     //文字型
    151     else if( type == DEF_CHAR ){
    152         if( isUnicode ) return sizeof( WORD );
    153         return sizeof( BYTE );
    154     }
    155 
    156     //ポインタ型
    157     else if(IsPtrType(type))        return PTR_SIZE;
    158 
    159     else if( type == DEF_STRUCT ){
    160         CClass *pobj_c;
    161         pobj_c=(CClass *)lpIndex;
    162         if(!pobj_c){
    163             SetError(300,NULL,cp);
    164             return 0;
    165         }
    166 
    167         return pobj_c->GetSize();
    168     }
    169 
    170     else if(type==DEF_OBJECT){
    171         return PTR_SIZE;
    172     }
    173     else{
    174         SetError(300,NULL,cp);
    175     }
    176     return 0;
    177 }
    178 int GetPtrType(int type,LONG_PTR lpIndex){
    179     return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
    180 }
    181 int GetTypeFixed(const char *TypeName,LONG_PTR *lpNum){
    182     int type;
    183 
    184     if(lpNum) *lpNum=-1;
    185 
    186     if(TypeName[0]=='*'){
    187         if(TypeName[1]==1&&(TypeName[2]==ESC_FUNCTION||TypeName[2]==ESC_SUB)){
    188             //関数ポインタ（*Function）
    189             return DEF_PTR_PROC;
    190         }
    191 
    192         type=GetTypeFixed(TypeName+1,lpNum);
    193         if(type==-1) return -1;
    194 
    195         return GetPtrType(type,*lpNum);
    196     }
    197 
    198     //整数型
    199     if(lstrcmpi(TypeName,"SByte")==0)           return DEF_SBYTE;
    200     else if(lstrcmpi(TypeName,"Byte")==0)       return DEF_BYTE;
    201     else if(lstrcmpi(TypeName,"Integer")==0)    return DEF_INTEGER;
    202     else if(lstrcmpi(TypeName,"WORD")==0)       return DEF_WORD;
    203     else if(lstrcmpi(TypeName,"Long")==0)       return DEF_LONG;
    204     else if(lstrcmpi(TypeName,"DWORD")==0)      return DEF_DWORD;
    205     else if(lstrcmpi(TypeName,"Int64")==0)      return DEF_INT64;
    206     else if(lstrcmpi(TypeName,"QWORD")==0)      return DEF_QWORD;
    207 
    208     //実数型
    209     else if(lstrcmpi(TypeName,"Single")==0)     return DEF_SINGLE;
    210     else if(lstrcmpi(TypeName,"Double")==0)     return DEF_DOUBLE;
    211 
    212     //文字型
    213     //else if( lstrcmpi( TypeName, "Char" ) == 0 ) return DEF_CHAR;
    214 
    215     //bool型
    216     else if( lstrcmpi( TypeName, "Boolean" ) == 0 ) return DEF_BOOLEAN;
    217 
    218     //ポインタ型
    219     //※VoidPtr型以外のポインタ型はTypeDef宣言により定義される
    220     else if(lstrcmpi(TypeName,"VoidPtr")==0)    return DEF_PTR_VOID;
    221 
    222     //その他
    223     else if(lstrcmpi(TypeName,"Any")==0)        return DEF_ANY;
    224 
    225 
    226     ////////////////////
    227     // TypeDefされた型
    228     ////////////////////
    229     int i;
    230     i=pobj_DBTypeDef->check(TypeName);
    231     if(i!=-1){
    232         return GetTypeFixed(pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName,lpNum);
    233     }
    234 
    235     if(!lpNum) return -1;
    236 
    237     //クラス
    238     CClass *pobj_c;
    239     pobj_c=pobj_DBClass->check(TypeName);
    240     if(pobj_c){
    241         *lpNum=(LONG_PTR)pobj_c;
    242 
    243         if( pobj_c->IsStructure() ){
    244             return DEF_STRUCT;
    245         }
    246         else{
    247             return DEF_OBJECT;
    248         }
    249     }
    250 
    251     return -1;
    252 }
    253 void GetOriginalTypeName(char *buffer){
    254     // TypeDefされた型に対して、オリジナルの型の名前に変更する
    255 
    256     if(buffer[0]=='*'){
    257         if(buffer[1]==1&&(buffer[2]==ESC_FUNCTION||buffer[2]==ESC_SUB)) return;
    258 
    259         GetOriginalTypeName(buffer+1);
    260         return;
    261     }
    262 
    263     int i;
    264     i=pobj_DBTypeDef->check(buffer);
    265     if(i!=-1){
    266         lstrcpy(buffer,pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName);
    267         GetOriginalTypeName(buffer);
    268     }
    269 }
    270 BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
    271     if(PTR_LEVEL(type)){
    272         //ポインタ型
    273         name[0]='*';
    274         return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
    275     }
    276 
    277     //整数型
    278     if(type==DEF_SBYTE)             lstrcpy(name,"SByte");
    279     else if(type==DEF_BYTE)         lstrcpy(name,"Byte");
    280     else if(type==DEF_INTEGER)      lstrcpy(name,"Integer");
    281     else if(type==DEF_WORD)         lstrcpy(name,"Word");
    282     else if(type==DEF_LONG)         lstrcpy(name,"Long");
    283     else if(type==DEF_DWORD)        lstrcpy(name,"DWord");
    284     else if(type==DEF_INT64)        lstrcpy(name,"Int64");
    285     else if(type==DEF_QWORD)        lstrcpy(name,"QWord");
    286 
    287     //実数型
    288     else if(type==DEF_SINGLE)       lstrcpy(name,"Single");
    289     else if(type==DEF_DOUBLE)       lstrcpy(name,"Double");
    290 
    291     //文字型
    292     //else if(type==DEF_CHAR)               lstrcpy(name,"Char");
    293 
    294     //bool型
    295     else if(type==DEF_BOOLEAN)      lstrcpy(name,"Boolean");
    296 
    297     //オブジェクト
    298     else if(type==DEF_OBJECT || type==DEF_STRUCT){
    299         if(lpIndex==0) lstrcpy(name,"non");
    300         else{
    301             lstrcpy(name,((CClass *)lpIndex)->name);
    302         }
    303     }
    304 
    305     //ポインタ型
    306     else if(type==DEF_PTR_VOID)     lstrcpy(name,"VoidPtr");
    307 
    308     else if(type==DEF_PTR_PROC){
    309         if(lpIndex==-1) lstrcpy(name,"VoidPtr");
    310         else{
    311             extern PROCPTRINFO *pProcPtrInfo;
    312             if(pProcPtrInfo[lpIndex].ReturnType==DEF_NON)
    313                 lstrcpy(name,"*Sub");
    314             else lstrcpy(name,"*Function");
    315         }
    316     }
    317 
    318     else{
    319         extern int cp;
    320         SetError(1,NULL,cp);
    321         return 0;
    322     }
    323     return 1;
    324 }
    325 
    326 TYPEINFO GetStringTypeInfo(){
    327     extern CClass *pobj_StringClass;
    328     TYPEINFO TypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
    329     return TypeInfo;
    330 }
    331 
    332 bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
    333     int p1 = 0, p2 = 0;
    334 
    335     for( int i=0; term[i]!='\0' ; i++ ){
    336 
    337         if( term[i] == '[' ){
    338             i = JumpStringInBracket( term, i + 1 );
    339             if( term[i] == '\0' ) break;
    340             continue;
    341         }
    342         if( term[i] == '(' ){
    343             int temp_p = i;
    344             i = JumpStringInPare( term, i + 1 ) + 1;
    345             if( term[i] == '\0' ) break;
    346             if( term[i] == '.'
    347                 || term[i] == 1 && term[i] == ESC_PSMEM ){
    348                     p1 = temp_p;
    349                     p2 = i;
    350             }
    351             continue;
    352         }
    353     }
    354     if( !p1 ) return false;
    355 
    356     //メソッド名
    357     memcpy( procName, term, p1 );
    358     procName[p1] = 0;
    359 
    360     //パラメータ
    361     memcpy( parameter, term + p1 + 1, p2 - p1 - 2 );
    362     parameter[ p2 - p1 - 2 ] = 0;
    363 
    364     //参照タイプ
    365     if( term[p2] == '.' ){
    366         refType = CClass::Dot;
    367     }
    368     else{
    369         refType = CClass::Pointer;
    370         p2++;
    371     }
    372 
    373     //メンバ
    374     lstrcpy( member, term + p2 + 1 );
    375 
    376     return true;
    377 }
    378 
    379 BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,CClass::RefType &refType){
    380     extern int cp;
    381     int i,i2,i3;
    382     char cPare_Open,cPare_Close;
    383 
    384     array[0]=0;
    385     array2[0]=0;
    386     NestMember[0]=0;
    387     for(i=0;;i++){
    388         if(buffer[i]=='\"'){
    389             for(i++;;i++){
    390                 if(IsDBCSLeadByte(buffer[i])){
    391                     i++;
    392                     continue;
    393                 }
    394                 if(buffer[i]=='\"') break;
    395             }
    396         }
    397         if(buffer[i]=='['||buffer[i]=='('){
    398             if(buffer[i]=='['){
    399                 cPare_Open='[';
    400                 cPare_Close=']';
    401             }
    402             else{
    403                 cPare_Open='(';
    404                 cPare_Close=')';
    405             }
    406             buffer[i]=0;
    407             for(i++,i2=0;;i++,i2++){
    408                 if(buffer[i]==cPare_Open){
    409                     if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buffer+i);
    410                     else i3=GetStringInPare(array+i2,buffer+i);
    411                     i+=i3-1;
    412                     i2+=i3-1;
    413                     continue;
    414                 }
    415                 if(buffer[i]==cPare_Close){
    416                     array[i2]=0;
    417                     break;
    418                 }
    419                 array[i2]=buffer[i];
    420             }
    421             if(buffer[i+1]==cPare_Open){
    422                 for(i+=2,i2=0;;i++,i2++){
    423                     if(buffer[i]==cPare_Open){
    424                         if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
    425                         else i3=GetStringInPare(array2+i2,buffer+i);
    426                         i+=i3-1;
    427                         i2+=i3-1;
    428                         continue;
    429                     }
    430                     if(buffer[i]==cPare_Close){
    431                         array2[i2]=0;
    432                         break;
    433                     }
    434                     array2[i2]=buffer[i];
    435                 }
    436                 if(buffer[i+1]==cPare_Open){
    437                     SetError(14,buffer,cp);
    438                     return 0;
    439                 }
    440             }
    441             continue;
    442         }
    443         if(buffer[i]=='.'){
    444             lstrcpy(NestMember,buffer+i+1);
    445             refType = CClass::Dot;
    446             buffer[i]=0;
    447             break;
    448         }
    449         if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
    450             lstrcpy(NestMember,buffer+i+2);
    451             refType = CClass::Pointer;
    452             buffer[i]=0;
    453             break;
    454         }
    455         if(buffer[i]=='\0') break;
    456     }
    457     return 1;
    458 }
    459 
    460 void GetArrayElement(char *buffer,char *variable,char *array_element){
    461     array_element[0]=0;
    462 
    463     if(buffer[lstrlen(buffer)-1]!=']'){
    464         lstrcpy(variable,buffer);
    465         return;
    466     }
    467 
    468     int i,i2;
    469     for(i=0;;i++){
    470         if(buffer[i]=='\0') break;
    471         if(buffer[i]=='['){
    472             i2=GetStringInBracket(array_element,buffer+i);
    473             i+=i2-1;
    474             continue;
    475         }
    476     }
    477 
    478     lstrcpy(variable,buffer);
    479     variable[lstrlen(variable)-lstrlen(array_element)]=0;
    480 
    481     RemoveStringBracket(array_element);
    482 }
    483 
    484 BOOL CheckVarNameError(char *name,int NowLine){
    485     int i2;
    486 
    487     if(!IsVariableTopChar(name[0])){
    488         SetError(1,NULL,NowLine);
    489         return 0;
    490     }
    491     for(i2=1;;i2++){
    492         if(name[i2]=='\0') break;
    493         if(!IsVariableChar(name[i2])){
    494             SetError(1,NULL,NowLine);
    495             return 0;
    496         }
    497     }
    498     return 1;
    499 }
    500 
    501 int JumpSubScripts(int *ss){
    502     //DIMで定義された並んだ配列の数だけアドレスを進める
    503     int i,i2;
    504     for(i=0,i2=1;i<255;i++){
    505         if(ss[i]==-1) break;
    506         i2*=ss[i]+1;
    507     }
    508     return i2;
    509 }
    510 void GetArrange(char *variable,char *variAnswer,int *SubScripts){
    511     extern int cp;
    512     int i,i2,i3,i4;
    513     double dbl;
    514     _int64 i64data;
    515     BOOL bBracket;
    516     char temporary[VN_SIZE];
    517 
    518     for(i=0;;i++){
    519         if(variable[i]=='('||variable[i]=='['){
    520             if(variable[i]=='[') bBracket=1;
    521             else bBracket=0;
    522 
    523             variAnswer[i]=0;
    524             for(i++,i2=0,i3=0;;i++,i2++){
    525                 if(variable[i]==','){
    526                     temporary[i2]=0;
    527 
    528                     i2=StaticCalculation(true, temporary,0,&i64data,0);
    529                     if(IsRealNumberType(i2)){
    530                         memcpy(&dbl,&i64data,sizeof(double));
    531                         i64data=(_int64)dbl;
    532                     }
    533 
    534                     if(i64data<0){
    535                         //error
    536                         SubScripts[i3]=0;
    537                     }
    538                     else SubScripts[i3]=(int)i64data;
    539                     i3++;
    540                     i2=-1;
    541                     continue;
    542                 }
    543                 if(variable[i]=='('){
    544                     i4=GetStringInPare(temporary+i2,variable+i);
    545                     i2+=i4-1;
    546                     i+=i4-1;
    547                     continue;
    548                 }
    549                 if(variable[i]=='['){
    550                     i4=GetStringInBracket(temporary+i2,variable+i);
    551                     i2+=i4-1;
    552                     i+=i4-1;
    553                     continue;
    554                 }
    555                 if(variable[i]==')'&&bBracket==0||
    556                     variable[i]==']'&&bBracket){
    557                     temporary[i2]=0;
    558                     if(i2==0){
    559                         SubScripts[i3]=-2;
    560                         break;
    561                     }
    562 
    563                     i2=StaticCalculation(true, temporary,0,&i64data,0);
    564                     if(IsRealNumberType(i2)){
    565                         memcpy(&dbl,&i64data,sizeof(double));
    566                         i64data=(_int64)dbl;
    567                     }
    568 
    569                     if(i64data<0){
    570                         //error
    571                         SubScripts[i3]=0;
    572                     }
    573                     else SubScripts[i3]=(int)i64data;
    574                     SubScripts[i3+1]=-1;
    575                     break;
    576                 }
    577                 if(variable[i]=='\"'){
    578                     SetError(1,NULL,cp);
    579                     return;
    580                 }
    581                 temporary[i2]=variable[i];
    582             }
    583             break;
    584         }
    585         variAnswer[i]=variable[i];
    586         if(variable[i]=='\0'){
    587             SubScripts[0]=-1;
    588             break;
    589         }
    590     }
    591 }
    592 
    593 int GetTypeFromSimpleName(char *variable){
    594     extern char DefIntVari[26],DefSngVari[26],DefStrVari[26],divNum,dsvNum,dStrvNum;
    595     int i;
    596     char name[VN_SIZE];
    597 
    598     //構造体メンバの場合を考慮
    599     for(i=lstrlen(variable);i>0;i--){
    600         if(variable[i]=='.'){
    601             i++;
    602             break;
    603         }
    604     }
    605 
    606     for(;;i++){
    607         if(variable[i]=='('||variable[i]=='\0'){
    608             name[i]=0;
    609             break;
    610         }
    611         name[i]=variable[i];
    612     }
    613     //変数名から選択
    614     i--;
    615     if(name[i]=='#') return DEF_DOUBLE;
    616     if(name[i]=='!') return DEF_SINGLE;
    617     if(name[i]=='%') return DEF_INTEGER;
    618     return DEF_DOUBLE;
    619 }
    620 
    621 
    622 int GetMemberType(CClass *pobj_c,char *member,LONG_PTR *plpNestIndex,BOOL bPrivateAccess,BOOL bError){
    623     extern int cp;
    624     int i;
    625 
    626     //クラス、配列の構成要素を解析する
    627     char VarName[VN_SIZE];      //変数名
    628     char array[VN_SIZE];        //第1次配列
    629     char lpPtrOffset[VN_SIZE];      //第2次配列
    630     char NestMember[VN_SIZE];   //入れ子メンバ
    631     CClass::RefType refType = CClass::Non;
    632     lstrcpy(VarName,member);
    633     if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
    634 
    635     for(i=0;i<pobj_c->iMemberNum;i++){
    636         if(lstrcmp(pobj_c->ppobj_Member[i]->name,VarName)==0) break;
    637     }
    638     if(i==pobj_c->iMemberNum){
    639         if(bError) SetError(103,VarName,cp);
    640         return -1;
    641     }
    642 
    643     //アクセシビリティをチェック
    644     if(pobj_c==pobj_CompilingClass){
    645         //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    646         if(pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
    647             if(bError) SetError(107,VarName,cp);
    648             return -1;
    649         }
    650     }
    651     else{
    652         if((bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)||
    653             pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
    654             if(bError) SetError(107,VarName,cp);
    655             return -1;
    656         }
    657         else if(bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PROTECTED){
    658             if(bError) SetError(108,VarName,cp);
    659             return -1;
    660         }
    661     }
    662 
    663     int type;
    664     type=pobj_c->ppobj_Member[i]->TypeInfo.type;
    665     *plpNestIndex=pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex;
    666 
    667     //ポインタ変数の場合
    668     if(IsPtrType(type)){
    669         if(pobj_c->ppobj_Member[i]->SubScripts[0]==-1){
    670             lstrcpy(lpPtrOffset,array);
    671             array[0]=0;
    672         }
    673     }
    674     else{
    675         if(lpPtrOffset[0]){
    676             if(bError) SetError(16,member,cp);
    677             return 0;
    678         }
    679     }
    680 
    681     if( refType != CClass::Non ){
    682         //入れ子構造の場合
    683 
    684         return GetMemberType(pobj_c->ppobj_Member[i]->TypeInfo.u.pobj_Class,
    685             NestMember,
    686             plpNestIndex,
    687             0,
    688             bError);
    689     }
    690 
    691     if(array[0]==0&&pobj_c->ppobj_Member[i]->SubScripts[0]!=-1){
    692         return type|FLAG_PTR;
    693     }
    694 
    695     if(lpPtrOffset[0]){
    696         if(PTR_LEVEL(type)){
    697             type=MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1);
    698         }
    699         else{
    700             //エラー
    701             if(bError) SetError(1,NULL,cp);
    702             return -1;
    703         }
    704     }
    705 
    706     return type;
    707 }
    708 int GetVarType(const char *NameBuffer,LONG_PTR *plpIndex,BOOL bError){
    709     extern BOOL bCompilingGlobal;
    710     int i;
    711     LONG_PTR lpIndex;
    712     char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
    713 
    714     if(NameBuffer[0]=='.'){
    715         GetWithName(variable);
    716         lstrcat(variable,NameBuffer);
    717     }
    718     else lstrcpy(variable,NameBuffer);
    719 
    720 
    721     CClass::RefType refType;
    722     if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
    723         // 戻り値オブジェクトのメンバを直接参照しているとき
    724         //例: func().member
    725 
    726         void *pInfo;
    727         int idProc=GetProc(VarName,&pInfo);
    728 
    729         if(idProc){
    730 
    731             int type=GetReturnTypeOfProc(idProc,pInfo,VarName,array,&lpIndex);
    732 
    733             return GetMemberType((CClass *)lpIndex,member,plpIndex,1,bError);
    734         }
    735     }
    736 
    737 
    738 
    739     lstrcpy(VarName,variable);
    740     GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
    741 
    742     int *pSubScripts;
    743     int type;
    744 
    745     extern int MaxGlobalVarNum;
    746     extern VARIABLE *GlobalVar;
    747     extern int MaxLocalVarNum;
    748     extern VARIABLE *LocalVar;
    749 
    750     if(bCompilingGlobal==0){
    751         /////////////////
    752         // ローカル変数
    753         /////////////////
    754 
    755         for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
    756             if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
    757                 && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
    758                 ){
    759                     if(lstrcmp(VarName,LocalVar[i].name)==0) break;
    760             }
    761         }
    762         if(i>=0){
    763             //ポインタ変数の場合
    764             if(IsPtrType(LocalVar[i].type)){
    765                 if(LocalVar[i].SubScripts[0]==-1){
    766                     lstrcpy(lpPtrOffset,array);
    767                     array[0]=0;
    768                 }
    769             }
    770             else{
    771                 if(lpPtrOffset[0]){
    772                     if(bError) SetError(16,variable,cp);
    773                     return -1;
    774                 }
    775             }
    776 
    777             type=LocalVar[i].type;
    778             lpIndex=LocalVar[i].u.index;
    779             pSubScripts=LocalVar[i].SubScripts;
    780 
    781             goto ok;
    782         }
    783     }
    784 
    785     if(pobj_CompilingClass){
    786         ///////////////////////
    787         // クラスメンバの参照
    788         ///////////////////////
    789 
    790         if(lstrcmpi(variable,"This")==0){
    791             //Thisオブジェクト
    792             *plpIndex=(LONG_PTR)pobj_CompilingClass;
    793             return DEF_OBJECT;
    794         }
    795 
    796         if(_memicmp(variable,"This.",5)==0){
    797             //Thisオブジェクトのメンバを参照するとき
    798             SlideString(variable+5,-5);
    799             lstrcpy(VarName,variable);
    800         }
    801         else{
    802             //クラス内メンバを参照するとき（通常）
    803 
    804             for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    805                 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
    806             }
    807             if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
    808         }
    809 
    810         return GetMemberType(pobj_CompilingClass,variable,plpIndex,1,bError);
    811     }
    812 
    813 NonClassMember:
    814 
    815     //////////////////////////
    816     // 静的ローカル変数
    817     // ※"Static.Object.Method.Variable"
    818     //////////////////////////
    819 
    820     char temporary[VN_SIZE];
    821     extern SubInfo *pCompilingSubInfo;
    822     if(pCompilingSubInfo){
    823         GetNowStaticVarFullName(VarName,temporary);
    824 
    825         for(i=0;i<MaxGlobalVarNum;i++){
    826             if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
    827         }
    828         if(i!=MaxGlobalVarNum){
    829             goto GlobalOk;
    830         }
    831     }
    832 
    833 
    834     //////////////////////////
    835     // クラスの静的メンバ
    836     //////////////////////////
    837 
    838     if(member[0]){
    839         lstrcpy(temporary,member);
    840         char tempMember[VN_SIZE];
    841         char tempArray[VN_SIZE];
    842         {
    843             CClass::RefType refType;
    844             GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
    845         }
    846 
    847         char temp2[VN_SIZE];
    848         sprintf(temp2,"%s.%s",VarName,temporary);
    849         for(i=0;i<MaxGlobalVarNum;i++){
    850             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    851         }
    852 
    853         if(i!=MaxGlobalVarNum){
    854             lstrcpy(member,tempMember);
    855             lstrcpy(array,tempArray);
    856             goto GlobalOk;
    857         }
    858     }
    859 
    860     if(pobj_CompilingClass){
    861         //自身のクラスから静的メンバを参照する場合
    862         char temp2[VN_SIZE];
    863         sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
    864         for(i=0;i<MaxGlobalVarNum;i++){
    865             if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
    866         }
    867 
    868         if(i!=MaxGlobalVarNum){
    869             goto GlobalOk;
    870         }
    871     }
    872 
    873 
    874     ////////////////////
    875     // グローバル変数
    876     ////////////////////
    877 
    878     for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
    879         if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
    880             && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
    881             ){
    882                 if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
    883         }
    884     }
    885 
    886     if(i>=0){
    887         goto GlobalOk;
    888     }
    889 
    890     //変数として見つからなかったとき
    891     if(bError) SetError(3,variable,cp);
    892     return -1;
    893 
    894 GlobalOk:
    895 
    896     //ポインタ変数の場合
    897     if(IsPtrType(GlobalVar[i].type)){
    898         if(GlobalVar[i].SubScripts[0]==-1){
    899             lstrcpy(lpPtrOffset,array);
    900             array[0]=0;
    901         }
    902     }
    903     else{
    904         if(lpPtrOffset[0]){
    905             if(bError) SetError(16,variable,cp);
    906             return -1;
    907         }
    908     }
    909 
    910     type=GlobalVar[i].type;
    911     lpIndex=GlobalVar[i].u.index;
    912     pSubScripts=GlobalVar[i].SubScripts;
    913 
    914 ok:
    915 
    916     if(member[0]){
    917         if( NATURAL_TYPE(type)==DEF_OBJECT
    918             || NATURAL_TYPE(type)==DEF_STRUCT){
    919                 return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
    920         }
    921     }
    922 
    923     if(array[0]==0&&pSubScripts[0]!=-1){
    924         //配列の先頭ポインタを示す場合
    925         type|=FLAG_PTR;
    926     }
    927 
    928     if(lpPtrOffset[0]){
    929         if(PTR_LEVEL(type)){
    930             type=MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1);
    931         }
    932         else{
    933             //エラー
    934             if(bError) SetError(1,NULL,cp);
    935             return -1;
    936         }
    937     }
    938 
    939     *plpIndex=lpIndex;
    940     return type;
    941 }
    942 
    943 BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
    944     //読み取り専用で変数へアクセス
    945     return GetVarOffset(
    946         true,       //エラー表示有効
    947         false,      //書き込みアクセスは無し
    948         NameBuffer,
    949         pType,
    950         pRelativeVar,
    951         plpIndex,
    952         pss);
    953 }
    954 BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
    955     //読み書き両用で変数へアクセス
    956     return GetVarOffset(
    957         true,       //エラー表示有効
    958         true,       //書き込みアクセス
    959         NameBuffer,
    960         pType,
    961         pRelativeVar,
    962         plpIndex,
    963         pss);
    964 }
    965 
    966 
    967 
    968 BOOL GetDimentionFormat(const char *buffer, const bool isRef, char *VarName,int *SubScripts,TYPEINFO *pTypeInfo,char *InitBuf,char *ConstractParameter){
    969     int i,i2,i3,IsStr;
    970     char variable[VN_SIZE],temporary[8192];
    971 
    972     for(i=0;;i++){
    973         if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
    974             buffer[i]=='='||
    975             buffer[i]=='\0'){
    976             variable[i]=0;
    977             break;
    978         }
    979         variable[i]=buffer[i];
    980     }
    981 
    982     if(buffer[i]=='='){
    983         ////////////////////////////////////
    984         // 初期化データが指定されいるとき
    985         ////////////////////////////////////
    986 
    987         for(i++,i2=0,IsStr=0;;i++,i2++){
    988             if(buffer[i]=='\"') IsStr^=1;
    989             if(buffer[i]=='('&&IsStr==0){
    990                 i3=GetStringInPare(InitBuf+i2,buffer+i);
    991                 i+=i3-1;
    992                 i2+=i3-1;
    993                 continue;
    994             }
    995             if(buffer[i]=='['&&IsStr==0){
    996                 i3=GetStringInBracket(InitBuf+i2,buffer+i);
    997                 i+=i3-1;
    998                 i2+=i3-1;
    999                 continue;
    1000             }
    1001             if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
    1002                 (buffer[i]==','&&IsStr==0)||
    1003                 buffer[i]=='\0'){
    1004                 InitBuf[i2]=0;
    1005                 break;
    1006             }
    1007             InitBuf[i2]=buffer[i];
    1008         }
    1009     }
    1010     else{
    1011         //初期化データなし
    1012         InitBuf[0]=0;
    1013     }
    1014 
    1015     ConstractParameter[0]=0;
    1016     if(buffer[i]==1&&buffer[i+1]==ESC_AS){
    1017         /////////////////////////////
    1018         // "As ～" による型指定あり
    1019         /////////////////////////////
    1020 
    1021         for(i+=2,i2=0;;i++,i2++){
    1022             if(buffer[i]==','||buffer[i]=='('||buffer[i]=='\0'){
    1023                 temporary[i2]=0;
    1024                 break;
    1025             }
    1026             temporary[i2]=buffer[i];
    1027         }
    1028         pTypeInfo->type=GetTypeFixed(temporary,&pTypeInfo->u.lpIndex);
    1029         if(pTypeInfo->type==-1){
    1030             SetError(3,temporary,cp);
    1031             pTypeInfo->type=DEF_LONG;
    1032         }
    1033 
    1034         if(pTypeInfo->type==DEF_PTR_PROC){
    1035             if(temporary[0]=='*'&&
    1036                 temporary[1]==1&&
    1037                 (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
    1038                 if(buffer[i]!='('){
    1039                     SetError(10,temporary,cp);
    1040                     return 0;
    1041                 }
    1042                 i3=GetStringInPare(temporary+3,buffer+i);
    1043                 i+=i3;
    1044                 i2+=i3;
    1045 
    1046                 if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
    1047                     temporary[i2++]=buffer[i++];
    1048                     temporary[i2++]=buffer[i++];
    1049                     for(;;i++,i2++){
    1050                         if(!IsVariableChar(buffer[i])){
    1051                             temporary[i2]=0;
    1052                             break;
    1053                         }
    1054                         temporary[i2]=buffer[i];
    1055                     }
    1056                 }
    1057             }
    1058             else{
    1059                 //TypeDefをする前のベース型を取得
    1060                 GetOriginalTypeName(temporary);
    1061             }
    1062 
    1063             if(temporary[3]!='('){
    1064                 SetError(10,temporary,cp);
    1065                 return 0;
    1066             }
    1067 
    1068             //関数ポインタ
    1069             pTypeInfo->u.lpIndex=AddProcPtrInfo(temporary+3,temporary[2]);
    1070         }
    1071 
    1072         if(buffer[i]=='('){
    1073             //コンストラクタに渡すパラメータを取得
    1074             i2=GetStringInPare(ConstractParameter,buffer+i);
    1075             i+=i2;
    1076             RemoveStringPare(ConstractParameter);
    1077 
    1078             if(pTypeInfo->type!=DEF_OBJECT){
    1079                 SetError(112,variable,cp);
    1080                 return 0;
    1081             }
    1082         }
    1083     }
    1084     else{
    1085         /////////////////
    1086         // As指定なし
    1087         /////////////////
    1088 
    1089         if( InitBuf[0] == '\0' ){
    1090             //As指定も、初期値指定もない場合
    1091             pTypeInfo->type=GetTypeFromSimpleName(variable);
    1092 
    1093             i2=lstrlen(variable)-1;
    1094             if(i2>=0){
    1095                 if(!(variable[i2]=='#'||variable[i2]=='!'||variable[i2]=='%'||variable[i2]=='$'))
    1096                     SetError(-103,variable,cp);
    1097             }
    1098         }
    1099         else{
    1100             //初期値の型を判別して自動的に型情報を付加する
    1101             TYPEINFO BaseType = GetStringTypeInfo();
    1102             int result = NumOpe_GetType_Old( InitBuf, &BaseType, &pTypeInfo->u.lpIndex );
    1103 
    1104             //エラーの場合
    1105             if( result == -1 ) return 0;
    1106 
    1107             pTypeInfo->type = result;
    1108         }
    1109 
    1110     }
    1111 
    1112     if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
    1113         //初期値とコンストラクタパラメータが同時に呼び出されているとき
    1114         SetError(132, NULL, cp);
    1115     }
    1116 
    1117     /*
    1118     TODO: 消す
    1119     if( pTypeInfo->type == DEF_OBJECT && InitBuf[0] != '\0' && InitBuf[0] != '[' && isRef == false ){
    1120         if( pTypeInfo->u.pobj_Class->GetCopyConstructorMethod() ){
    1121             //オブジェクトでコピーコンストラクタが存在するとき
    1122             lstrcpy( ConstractParameter, InitBuf );
    1123             InitBuf[0] = 0;
    1124         }
    1125     }*/
    1126 
    1127     GetArrange(variable,VarName,SubScripts);
    1128     return 1;
    1129 }
    1130 
    1131 BOOL GetNowStaticVarFullName(char *VarName,char *FullName){
    1132     extern SubInfo *pCompilingSubInfo;
    1133     if(!pCompilingSubInfo) return 0;
    1134 
    1135     //Static識別
    1136     lstrcpy(FullName,"Static%");
    1137 
    1138     //クラス名
    1139     if(pobj_CompilingClass){
    1140         lstrcat(FullName,pobj_CompilingClass->name);
    1141         lstrcat(FullName,"%");
    1142     }
    1143 
    1144     //関数（またはメソッド）名
    1145     lstrcat(FullName,pCompilingSubInfo->name);
    1146     lstrcat(FullName,"%");
    1147 
    1148     //ID
    1149     char temp[255];
    1150     sprintf(temp,"%x",pCompilingSubInfo->id);
    1151     lstrcat(FullName,temp);
    1152     lstrcat(FullName,"%");
    1153 
    1154     //変数名
    1155     lstrcat(FullName,VarName);
    1156 
    1157     return 1;
    1158 }
    1159 
    1160 
    1161 void AddGlobalVariable(bool isRef, char *name,int *SubScripts,TYPEINFO *pTypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlag){
    1162     /////////////////////////
    1163     // グローバル変数を追加
    1164     /////////////////////////
    1165     extern VARIABLE *GlobalVar;
    1166     extern int MaxGlobalVarNum;
    1167     extern int AllInitGlobalVarSize;
    1168     extern int AllGlobalVarSize;
    1169 
    1170     int i2,i3,VarSize;
    1171 
    1172     for(i2=0;i2<MaxGlobalVarNum;i2++){
    1173         if(GlobalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==GlobalVar[i2].ScopeLevel){
    1174             if(lstrcmp(GlobalVar[i2].name,name)==0){
    1175                 //２重定義のエラー
    1176                 SetError(15,name,cp);
    1177                 return;
    1178             }
    1179         }
    1180     }
    1181 
    1182     GlobalVar=(VARIABLE *)HeapReAlloc(hHeap,0,GlobalVar,(MaxGlobalVarNum+1)*sizeof(VARIABLE));
    1183     VARIABLE *pVar = &GlobalVar[MaxGlobalVarNum];
    1184     MaxGlobalVarNum++;
    1185 
    1186     if( isRef ){
    1187         //参照型
    1188         pVar->fRef = REF_VARIABLE;
    1189         TypeSize = PTR_SIZE;
    1190     }
    1191     else pVar->fRef=0;
    1192 
    1193     for(i2=1,i3=0;i3<255;i3++){
    1194         //配列要素数
    1195         pVar->SubScripts[i3]=SubScripts[i3];
    1196 
    1197         if(SubScripts[i3]==-1) break;
    1198         i2*=SubScripts[i3]+1;
    1199     }
    1200     VarSize=TypeSize*i2;
    1201     if(VarSize%PTR_SIZE) VarSize+=PTR_SIZE-(VarSize%PTR_SIZE);
    1202 
    1203     lstrcpy(pVar->name,name);
    1204     if(dwFlag & DIMFLAG_CONST) pVar->bConst = true;
    1205     else pVar->bConst = false;
    1206     if(SubScripts[0]==-1) pVar->bArray=0;
    1207     else pVar->bArray=1;
    1208     pVar->type=pTypeInfo->type;
    1209     pVar->u.index=pTypeInfo->u.lpIndex;
    1210 
    1211     //コンストラクタ用パラメータ
    1212     pVar->ConstractParameter=(char *)HeapAlloc(hHeap,0,lstrlen(ConstractParameter)+1);
    1213     lstrcpy(pVar->ConstractParameter,ConstractParameter);
    1214 
    1215     //レキシカルスコープ
    1216     pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
    1217     pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
    1218     pVar->bLiving=TRUE;
    1219 
    1220     //エラー用
    1221     pVar->source_code_address=cp;
    1222 
    1223     //アラインメントを考慮
    1224     int alignment = 0;
    1225     if( pVar->type==DEF_STRUCT ){
    1226         alignment = pVar->u.pobj_c->iAlign;
    1227     }
    1228 
    1229     if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
    1230         //初期バッファがあるとき
    1231 
    1232         if( alignment ){
    1233             if( AllInitGlobalVarSize % alignment ){
    1234                 AllInitGlobalVarSize += alignment - (AllInitGlobalVarSize % alignment);
    1235             }
    1236         }
    1237 
    1238         pVar->offset=AllInitGlobalVarSize;
    1239         AllInitGlobalVarSize+=VarSize;
    1240     }
    1241     else{
    1242         //初期バッファがないとき
    1243 
    1244         if( alignment ){
    1245             if( AllGlobalVarSize % alignment ){
    1246                 AllGlobalVarSize += alignment - (AllGlobalVarSize % alignment);
    1247             }
    1248         }
    1249 
    1250         pVar->offset=AllGlobalVarSize | 0x80000000;
    1251         AllGlobalVarSize+=VarSize;
    1252     }
    1253 
    1254     if(InitBuf[0]){
    1255         int result = 0;
    1256         if( pVar->type != DEF_OBJECT ){
    1257             //初期バッファにデータをセット
    1258             extern BYTE *initGlobalBuf;
    1259             initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
    1260                 HEAP_ZERO_MEMORY,
    1261                 initGlobalBuf,
    1262                 AllInitGlobalVarSize);
    1263 
    1264             result = SetInitGlobalData(pVar->offset,
    1265                 pVar->type,
    1266                 pVar->u.index,
    1267                 pVar->SubScripts,
    1268                 InitBuf);
    1269         }
    1270 
    1271         if(!result){
    1272             //動的な式だった場合は代入演算を行う
    1273 
    1274             //初期代入時のみ、書き込みアクセスを許可する
    1275             bool bConstBack = pVar->bConst;
    1276             pVar->bConst = false;
    1277 
    1278             //代入
    1279             char temporary[8192];
    1280             sprintf(temporary,"%s=%s",name,InitBuf);
    1281             OpcodeCalc(temporary);
    1282 
    1283             //アクセス制限を元に戻す
    1284             pVar->bConst = bConstBack;
    1285         }
    1286     }
    1287 
    1288 
    1289     if( pTypeInfo->type==DEF_OBJECT ){
    1290         //デストラクタの利用フラグをオンにする
    1291         CMethod *method = pTypeInfo->u.pobj_Class->GetDestructorMethod();
    1292         if( method ){
    1293             method->psi->bUse = 1;
    1294         }
    1295     }
    1296 
    1297 /*
    1298     TODO: 消す
    1299     if(pTypeInfo->type==DEF_OBJECT){
    1300         //利用対象のクラスコンストラクタ、デストラクタに使用チェックをつける
    1301         for(i2=0;i2<pTypeInfo->u.pobj_Class->iMethodNum;i2++){
    1302             if(lstrcmp(pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->name,pTypeInfo->u.pobj_Class->name)==0){
    1303                 //コンストラクタ
    1304                 pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->bUse=1;
    1305             }
    1306             if(pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->name[0]=='~'){
    1307                 //デストラクタ
    1308                 pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->bUse=1;
    1309             }
    1310         }
    1311     }*/
    1312 }
Note: See TracChangeset for help on using the changeset viewer.