Changeset 78 in dev for BasicCompiler_Common


Ignore:
Timestamp:
Mar 25, 2007, 2:47:49 AM (18 years ago)
Author:
dai_9181
Message:

CTypeDef → TypeDef
Houseクラスを追加。
オーバーロードレベルの種類を追加（レベル1に挿入）

Location:
BasicCompiler_Common
Files:
4 added
22 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler_Common/BasicCompiler.cpp

    r69 r78  
    540540    char temporary[1024],temp2[MAX_PATH];
    541541
     542    //MessageBox(0,"starting compiler/debugger","ActiveBasic",MB_OK);
     543
    542544    //コモンコントロールを初期化
    543545    InitCommonControls();

  • BasicCompiler_Common/BasicCompiler.h

    r75 r78  
    2929DllProc **ppDeclareHash;
    3030CONSTINFO **ppConstHash;
    31 ProcPointer **ppProcPointer;
    32 int ProcPtrInfoNum;
    3331
    3432ERRORINFO *pErrorInfo;

  • BasicCompiler_Common/Class.h

    r75 r78  
     1#pragma once
     2
    13#include <vector>
    24#include "Type.h"

  • BasicCompiler_Common/Compile.cpp

    r64 r78  
    154154
    155155            case ESC_TYPEDEF:
     156                //既に収集済み
    156157                break;
    157158

  • BasicCompiler_Common/DebugMiddleFile.cpp

    r76 r78  
    138138    // TypeDef情報
    139139    //////////////////
    140 
    141     extern CDBTypeDef *pobj_DBTypeDef;
    142     *(long *)(buffer+i2)=pobj_DBTypeDef->iNum;
    143     i2+=sizeof(long);
    144     for(i3=0;i3<pobj_DBTypeDef->iNum;i3++){
    145         lstrcpy(buffer+i2,pobj_DBTypeDef->ppobj_TypeDef[i3]->lpszName);
    146         i2+=lstrlen(buffer+i2)+1;
    147 
    148         lstrcpy(buffer+i2,pobj_DBTypeDef->ppobj_TypeDef[i3]->lpszBaseName);
     140    *(long *)(buffer+i2)=House::typeDefs.size();
     141    i2+=sizeof(long);
     142    for(i3=0;i3<(int)House::typeDefs.size();i3++){
     143        lstrcpy(buffer+i2,House::typeDefs[i3].GetNewName().c_str() );
     144        i2+=lstrlen(buffer+i2)+1;
     145
     146        lstrcpy(buffer+i2,House::typeDefs[i3].GetBaseName().c_str() );
    149147        i2+=lstrlen(buffer+i2)+1;
    150148
    … …  
    507505
    508506    //初期化
    509     pobj_DBTypeDef=new CDBTypeDef;
     507    House::typeDefs.clear();
    510508
    511509    //個数を取得
    … …  
    516514        i2+=lstrlen(buffer+i2)+1;
    517515
    518         pobj_DBTypeDef->add(temp5,buffer+i2);
    519 
    520         i2+=lstrlen(buffer+i2)+1;
    521     }
    522 
    523     extern CDBTypeDef *pobj_DBTypeDef;
    524     pobj_DBTypeDef=this->pobj_DBTypeDef;
     516        House::typeDefs.push_back( TypeDef( temp5, buffer+i2 ) );
     517
     518        i2+=lstrlen(buffer+i2)+1;
     519    }
    525520
    526521    //定数を取得
    … …  
    954949    pobj_DBClass=this->pobj_DBClass;
    955950
    956     // TypeDef情報
    957     extern CDBTypeDef *pobj_DBTypeDef;
    958     pobj_DBTypeDef=this->pobj_DBTypeDef;
    959 
    960951    //定数を取得
    961952    extern CONSTINFO **ppConstHash;

  • BasicCompiler_Common/DebugSection.h

    r75 r78  
    3434    // クラス情報
    3535    CDBClass *pobj_DBClass;
    36 
    37     // TypeDef情報
    38     CDBTypeDef *pobj_DBTypeDef;
    3936
    4037    //定数を取得

  • BasicCompiler_Common/Intermediate_Step2.cpp

    r75 r78  
    185185        temporary[i2]=buffer[i];
    186186    }
    187 
    188     //新しい型情報を追加
    189     pobj_DBTypeDef->add(temporary,"Long");
    190187
    191188    if(buffer[i]=='\0'){
    … …  
    379376            case ESC_TYPEDEF:
    380377                KillStringSpaces(Command+2);
    381                 AddTypeDefData(Command+2);
    382378                break;
    383379            case ESC_DECLARE:

  • BasicCompiler_Common/MakeExe.cpp

    r76 r78  
    147147    ppConstHash=(CONSTINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(CONSTINFO *));
    148148    */
    149 
    150     //TypeDef情報を初期化
    151     pobj_DBTypeDef=new CDBTypeDef();
    152149
    153150    //コンパイルダイアログのプログレスバーを上げる
    … …  
    212209    HeapDefaultFree(pLineInfo);
    213210
    214     //TypeDef情報を初期化
    215     delete pobj_DBTypeDef;
    216     pobj_DBTypeDef=0;
    217 
    218211    //サブルーチン（ユーザー定義）情報のメモリ解放
    219212    extern UserProc **ppSubHash;

  • BasicCompiler_Common/ParamImpl.cpp

    r77 r78  
    66#include "../BasicCompiler32/opcode.h"
    77#endif
     8
     9#define OVERLOAD_MIN_LEVEL 0
     10#define OVERLOAD_MAX_LEVEL 4
     11#define OVERLOAD_LEVEL0 0       // 型調整なし。厳密に等しい
     12#define OVERLOAD_LEVEL1 1       // 型調整なし。整数型/実数型レベルでの同一性チェック
     13#define OVERLOAD_LEVEL2 2       // 型調整あり。厳密に等しい
     14#define OVERLOAD_LEVEL3 3       // 型調整あり。整数型/実数型レベルでの同一性チェック
     15#define OVERLOAD_LEVEL4 4       // 型調整あり。数値型/クラス型レベルでの同一性チェック
    816
    917ParamImpl::ParamImpl(const char *buffer):
    … …  
    119127
    120128            NumOpe_GetType(Parms[i],
    121                 (level==OVERLOAD_LEVEL0)? nullParam : param,
     129                (level==OVERLOAD_LEVEL0 || level == OVERLOAD_LEVEL1)? nullParam : param,
    122130                argType);
    123131        }
    … …  
    127135
    128136        if(argType.GetBasicType()!=param.GetBasicType()){
    129             if(level==OVERLOAD_LEVEL1 || level == OVERLOAD_LEVEL0){
     137            if( level == OVERLOAD_LEVEL0 || level==OVERLOAD_LEVEL2 ){
    130138                return false;
    131139            }
    132             else if(level==OVERLOAD_LEVEL2){
     140            else if( level == OVERLOAD_LEVEL1 || level==OVERLOAD_LEVEL3){
    133141                if(!(
    134                     IsWholeNumberType(argType.GetBasicType())&&IsWholeNumberType(param.GetBasicType())||
    135                     IsRealNumberType(argType.GetBasicType())&&IsRealNumberType(param.GetBasicType())
     142                    argType.IsWhole()&&param.IsWhole()||
     143                    argType.IsReal()&&param.IsReal()
    136144                    )){
    137145                        return false;
    138146                }
    139147            }
    140             else if(level==OVERLOAD_LEVEL3){
    141                 if(argType.GetBasicType()==DEF_OBJECT||param.GetBasicType()==DEF_OBJECT) return false;
     148            else if(level==OVERLOAD_LEVEL4){
     149                if(argType.IsObject()||param.IsObject()) return false;
    142150            }
    143151        }

  • BasicCompiler_Common/Parameter.h

    r77 r78  
     1#pragma once
     2
    13#include "Type.h"
    2 
    3 #ifndef _ACTIVEBASIC_COMPILER_PARAMETER_H
    4 #define _ACTIVEBASIC_COMPILER_PARAMETER_H
    54
    65class Parameter;
    … …  
    106105    }
    107106};
    108 
    109 #endif //_ACTIVEBASIC_COMPILER_PARAMETER_H

  • BasicCompiler_Common/Procedure.cpp

    r77 r78  
    120120            Type::StringToType( temporary, type );
    121121
     122            /*
     123            TODO: 消す(TypeDef関連の変更)
    122124            if(temporary[0]=='*'&&
    123125                temporary[1]==1&&
    … …  
    145147            else{
    146148                //TypeDefをする前のベース型を取得
    147                 GetOriginalTypeName(temporary);
    148             }
     149                GetOriginalTypeName_Old(temporary);
     150            }*/
    149151
    150152            if( type.IsNull() ){
    … …  
    158160        }
    159161
     162        /*
     163        TODO: 消す(TypeDef関連の変更)
    160164        if( type.IsProcPtr() ){
    161165            //関数ポインタの場合
    162166            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine) );
    163         }
     167        }*/
    164168
    165169        Parameter *pParam = new Parameter( name, type, isRef, initValue );
    … …  
    274278                Type::StringToType( temporary, type );
    275279
     280                /*
     281                TODO: 消す(TypeDef関連の変更)
    276282                if(temporary[0]=='*'&&
    277283                    temporary[1]==1&&
    … …  
    299305                else{
    300306                    //TypeDefをする前のベース型を取得
    301                     GetOriginalTypeName(temporary);
    302                 }
     307                    GetOriginalTypeName_Old(temporary);
     308                }*/
    303309
    304310                if( type.IsNull() ){
    … …  
    312318            }
    313319
     320            /*
     321            TODO: 消す(TypeDef関連の変更)
    314322            if( type.IsProcPtr() ){
    315323                //関数ポインタの場合
    316324                type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine) );
    317             }
     325            }*/
    318326
    319327            Parameter *pParam = new Parameter( name, type, isRef );
    … …  
    527535            Type::StringToType( temporary, type );
    528536
     537            /*
     538            TODO: 消す(TypeDef関連の変更)
    529539            if(temporary[0]=='*'&&
    530540                temporary[1]==1&&
    … …  
    552562            else{
    553563                //TypeDefをする前のベース型を取得
    554                 GetOriginalTypeName(temporary);
    555             }
     564                GetOriginalTypeName_Old(temporary);
     565            }*/
    556566
    557567            if( type.IsNull() ){
    … …  
    565575        }
    566576
     577        /*
     578        TODO: 消す(TypeDef関連の変更)
    567579        if( type.IsProcPtr() ){
    568580            //関数ポインタの場合
    569581            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine ) );
    570         }
     582        }*/
    571583
    572584        Parameter *pParam = new Parameter( name, type, isRef );
    … …  
    731743            Type::StringToType( temporary, type );
    732744
     745            /*
     746            TODO: 消す(TypeDef関連の変更)
    733747            if(temporary[0]=='*'&&
    734748                temporary[1]==1&&
    … …  
    756770            else{
    757771                //TypeDefをする前のベース型を取得
    758                 GetOriginalTypeName(temporary);
    759             }
     772                GetOriginalTypeName_Old(temporary);
     773            }*/
    760774
    761775            if( type.IsNull() ){
    … …  
    769783        }
    770784
     785        /*
     786        TODO: 消す(TypeDef関連の変更)
    771787        if( type.IsProcPtr() ){
    772788            //関数ポインタの場合
    773789            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine ) );
    774         }
     790        }*/
    775791
    776792        Parameter *pParam = new Parameter( name, type, isRef );

  • BasicCompiler_Common/Procedure.h

    r76 r78  
     1#pragma once
    12
    23class Procedure{

  • BasicCompiler_Common/Subroutine.cpp

    r75 r78  
    180180        GetVarType(fullCallName,type,false);
    181181
    182         extern ProcPointer **ppProcPointer;
    183         ProcPointer *pProcPtr = ppProcPointer[type.GetIndex()];
     182        ProcPointer *pProcPtr = House::procPointers[type.GetIndex()];
    184183        resultType = pProcPtr->ReturnType();
    185184
    … …  
    768767///////////////////////
    769768
    770 int AddProcPtrInfo( char *buffer, DWORD dwProcType, int nowLine ){
     769int AddProcPtrInfo( const string &typeExpression, int nowLine ){
     770    DWORD dwProcType = (DWORD)typeExpression[2];
     771    const string &paramStr = typeExpression.substr( 3 );
    771772
    772773    Procedure::Kind kind = Procedure::Sub;
    … …  
    778779
    779780    //buffer[0]は'('となっている
    780     pProcPointer->SetParamsAndReturnType( buffer, nowLine );
    781 
    782     extern ProcPointer **ppProcPointer;
    783     extern int ProcPtrInfoNum;
    784     ppProcPointer=(ProcPointer **)HeapReAlloc(hHeap,0,ppProcPointer,(ProcPtrInfoNum+1)*sizeof(ProcPointer *));
    785     ppProcPointer[ProcPtrInfoNum] = pProcPointer;
    786     ProcPtrInfoNum++;
    787 
    788     return ProcPtrInfoNum-1;
     781    pProcPointer->SetParamsAndReturnType( paramStr.c_str(), nowLine );
     782
     783    House::procPointers.push_back( pProcPointer );
     784
     785    return House::procPointers.size()-1;
    789786}
    790787void DeleteProcPtrInfo(void){
    791     extern ProcPointer **ppProcPointer;
    792     extern int ProcPtrInfoNum;
    793 
    794     for(int i=0;i<ProcPtrInfoNum;i++){
    795         delete ppProcPointer[i];
    796     }
    797 
    798     HeapDefaultFree(ppProcPointer);
    799 }
     788    BOOST_FOREACH( ProcPointer *pProcPointer, House::procPointers ){
     789        delete pProcPointer;
     790    }
     791
     792    House::procPointers.clear();
     793}

  • BasicCompiler_Common/Type.cpp

    r77 r78  
    6565                //関数ポインタ（*Function）
    6666                type.basicType = DEF_PTR_PROC;
     67                type.index = AddProcPtrInfo( typeName, cp );
    6768                return true;
    6869        }
    6970
    70         string nextTypeName = typeName.substr( 1 );
     71        const string &nextTypeName = typeName.substr( 1 );
    7172
    7273        if( !StringToType( nextTypeName, type ) ){
    … …  
    8889    // TypeDefされた型
    8990    ////////////////////
    90     int i=pobj_DBTypeDef->check( typeName.c_str() );
     91    int i=House::typeDefs.GetIndex( typeName.c_str() );
    9192    if(i!=-1){
    92         return StringToType( pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName, type );
     93        type = House::typeDefs[i].GetBaseType();
     94        return true;
    9395    }
    9496
    … …  
    461463        }
    462464        else{
    463             extern ProcPointer **ppProcPointer;
    464             if( ppProcPointer[index]->ReturnType().IsNull() ){
     465            if( House::procPointers[index]->ReturnType().IsNull() ){
    465466                return "*Sub";
    466467            }

  • BasicCompiler_Common/TypeDef.cpp

    r46 r78  
    1 #include "../BasicCompiler_Common/common.h"
     1#include "common.h"
    22
    33
    4 CDBTypeDef *pobj_DBTypeDef;
    5 
    6 
    7 CTypeDef::CTypeDef(const char *name,char *base){
    8     lpszName=(char *)malloc(lstrlen(name)+1);
    9     lstrcpy(lpszName,name);
    10     lpszBaseName=(char *)malloc(lstrlen(base)+1);
    11     lstrcpy(lpszBaseName,base);
     4TypeDef::TypeDef( const string &newName, const string &baseName ):
     5    newName( newName ),
     6    baseName( baseName )
     7{
     8    if( !Type::StringToType( baseName, baseType ) ){
     9        SetError(3, baseName, cp );
     10        return;
     11    }
    1212}
    13 CTypeDef::~CTypeDef(){
    14     free(lpszName);
    15     free(lpszBaseName);
     13TypeDef::~TypeDef(){
    1614}
    1715
    1816
    19 CDBTypeDef::CDBTypeDef(){
    20     ppobj_TypeDef=(CTypeDef **)malloc(1);
    21     iNum=0;
     17TypeDefCollection::TypeDefCollection(){
    2218}
    23 CDBTypeDef::~CDBTypeDef(){
    24     init();
    25     free(ppobj_TypeDef);
     19TypeDefCollection::~TypeDefCollection(){
    2620}
    27 void CDBTypeDef::init(){
    28     int i;
    29     for(i=0;i<iNum;i++){
    30         delete ppobj_TypeDef[i];
    31     }
    32     iNum=0;
    33 }
    34 void CDBTypeDef::add(const char *name,char *base){
    35     ppobj_TypeDef=(CTypeDef **)realloc(ppobj_TypeDef,(iNum+1)*sizeof(CTypeDef *));
    36     ppobj_TypeDef[iNum]=new CTypeDef(name,base);
    37     iNum++;
     21void TypeDefCollection::Add( const string &newName, const string &baseName ){
     22    TypeDef typeDef( newName, baseName );
     23    this->push_back( typeDef );
    3824
    3925
     26    /*
     27    TODO: 消す1
    4028    ////////////////////////
    4129    // 循環参照をチェック
    … …  
    4331
    4432    int i;
    45     char temporary[1024];
    46     lstrcpy(temporary,base);
     33    string tempName = newName;
    4734
    4835    while(1){
    49         i=check(temporary);
     36        i=GetIndex( tempName );
    5037        if(i==-1) break;
    5138
    52         if(lstrcmp(base,ppobj_TypeDef[i]->lpszBaseName)==0){
     39        if( (*this)[i].baseName == newName ){
    5340            //循環エラー
    5441            extern int cp;
    … …  
    5643
    5744            //不明な型として、Long型を指定しておく
    58             ppobj_TypeDef[i]->lpszBaseName=(char *)realloc(ppobj_TypeDef[i]->lpszBaseName,5);
    59             lstrcpy(ppobj_TypeDef[i]->lpszBaseName,"Long");
     45            (*this)[i].baseName = "Long";
    6046
    6147            break;
    6248        }
    6349
    64         lstrcpy(temporary,ppobj_TypeDef[i]->lpszBaseName);
    65     }
     50        tempName = (*this)[i].baseName;
     51    }*/
    6652}
    67 int CDBTypeDef::check(const char *name){
    68     int i;
    69     for(i=0;i<iNum;i++){
    70         if(lstrcmp(ppobj_TypeDef[i]->lpszName,name)==0){
     53int TypeDefCollection::GetIndex( const string &typeName ) const{
     54    int max = (*this).size();
     55    for( int i=0; i<max; i++ ){
     56        if( (*this)[i].newName == typeName ){
    7157            return i;
    7258        }
    … …  
    7561}
    7662
    77 
    78 
    79 void AddTypeDefData(char *Command){
    80     extern int cp;
     63void TypeDefCollection::Add( const string &expression, int nowLine ){
    8164    int i;
    82     char temporary[VN_SIZE],*pTemp;
     65    char temporary[VN_SIZE];
    8366
    8467    for(i=0;;i++){
    85         if(Command[i]=='='||Command[i]=='\0'){
     68        if(expression[i]=='='||expression[i]=='\0'){
    8669            temporary[i]=0;
    8770            break;
    8871        }
    89         temporary[i]=Command[i];
     72        temporary[i]=expression[i];
    9073    }
    9174
    92     if(Command[i]!='='){
    93         SetError(10,"TypeDef",cp);
     75    if(expression[i]!='='){
     76        SetError(10,"TypeDef",nowLine);
    9477        return;
    9578    }
    9679
    97     pTemp=Command+i+1;
     80    const char *pTemp=expression.c_str()+i+1;
    9881
    9982    //識別文字のエラーチェック（新しい型）
    … …  
    10285        if(temporary[i]=='\0') break;
    10386        if(!IsVariableChar(temporary[i])){
    104             SetError(10,"TypeDef",cp);
     87            SetError(10,"TypeDef",nowLine);
    10588            return;
    10689        }
    … …  
    11194        //関数ポインタ
    11295        if(pTemp[3]!='('){
    113             SetError(10,"TypeDef",cp);
     96            SetError(10,"TypeDef",nowLine);
    11497            return;
    11598        }
    … …  
    121104            if(pTemp[i]=='\0') break;
    122105            if(!IsVariableChar(pTemp[i])){
    123                 SetError(10,"TypeDef",cp);
     106                SetError(10,"TypeDef",nowLine);
    124107                return;
    125108            }
    … …  
    129112    //識別子が重複している場合はエラーにする
    130113    if(lstrcmp(temporary,pTemp)==0){
    131         SetError(1,NULL,cp);
     114        SetError(1,NULL,nowLine);
    132115        return;
    133116    }
    … …  
    138121    // TypeDef情報を追加
    139122    //////////////////////////
    140     pobj_DBTypeDef->add(temporary,pTemp);
     123
     124    //エラー用
     125    extern int cp;
     126    cp = nowLine;
     127
     128    House::typeDefs.Add(temporary,pTemp);
    141129}
     130
     131void TypeDefCollection::Init(){
     132    // 初期化
     133    clear();
     134
     135    int i=-1;
     136    while(1){
     137        i++;
     138
     139        extern char *basbuf;
     140        if( basbuf[i]==1 ){
     141            char temporary[VN_SIZE];
     142            if(basbuf[i+1]==ESC_TYPEDEF){
     143                int i2 = 0;
     144                for(i+=2;;i2++,i++){
     145                    if(basbuf[i]=='\n'){
     146                        temporary[i2]=0;
     147                        break;
     148                    }
     149                    temporary[i2]=basbuf[i];
     150                    if(basbuf[i]=='\0') break;
     151                }
     152                Add(temporary,i);
     153
     154                continue;
     155            }
     156            else if( basbuf[i+1] == ESC_CONST && basbuf[i+2] == 1 && basbuf[i+3] == ESC_ENUM ){
     157                int i2 = 0;
     158                for(i+=4;;i2++,i++){
     159                    if(!IsVariableChar(basbuf[i])){
     160                        temporary[i2]=0;
     161                        break;
     162                    }
     163                    temporary[i2]=basbuf[i];
     164                    if(basbuf[i]=='\0') break;
     165                }
     166                House::typeDefs.Add(temporary,"Long");
     167            }
     168        }
     169
     170        //次の行
     171        for(;;i++){
     172            if(IsCommandDelimitation(basbuf[i])) break;
     173        }
     174        if(basbuf[i]=='\0') break;
     175    }
     176}

  • BasicCompiler_Common/TypeDef.h

    r46 r78  
     1#pragma once
    12
    2 class CTypeDef{
     3#include <vector>
     4#include <string>
     5
     6#include "../Type.h"
     7
     8using namespace std;
     9
     10class TypeDefCollection;
     11
     12class TypeDef{
     13    friend TypeDefCollection;
     14
     15    string newName;
     16    string baseName;
     17    Type baseType;
    318public:
    4     char *lpszName;
    5     char *lpszBaseName;
    6     CTypeDef(const char *name,char *base);
    7     ~CTypeDef();
     19    TypeDef( const string &newName, const string &baseName );
     20    ~TypeDef();
     21
     22    const string &GetNewName(){
     23        return newName;
     24    }
     25    const string &GetBaseName(){
     26        return baseName;
     27    }
     28    const Type &GetBaseType(){
     29        return baseType;
     30    }
    831};
    932
    10 class CDBTypeDef{
     33class TypeDefCollection : public vector<TypeDef>
     34{
    1135public:
    12     CTypeDef **ppobj_TypeDef;
    13     int iNum;
    14     CDBTypeDef();
    15     ~CDBTypeDef();
     36    TypeDefCollection();
     37    ~TypeDefCollection();
    1638
    17     void init();
     39    void Add( const string &newName, const string &baseName );
     40    int GetIndex( const string &typeName ) const;
    1841
    19     void add(const char *name,char *base);
    20     int check(const char *name);
     42private:
     43    void Add( const string &expression, int nowLine );
     44public:
     45    void Init();
    2146};
    22 extern CDBTypeDef *pobj_DBTypeDef;
    23 
    24 
    25 void AddTypeDefData(char *Command);

  • BasicCompiler_Common/VarList.cpp

    r76 r78  
    2929        }
    3030
    31         sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,(DWORD64)offset);
     31        sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,(ULONG_PTR)offset);
    3232        lptv->item.iImage=1;
    3333        lptv->item.iSelectedImage=1;
    … …  
    4040        i2=ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&accessBytes);
    4141
    42         sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_POINTEROFOBJECT,(DWORD64)pData);
     42        sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_POINTEROFOBJECT,(ULONG_PTR)pData);
    4343        lptv->item.iImage=4;
    4444        lptv->item.iSelectedImage=4;
    … …  
    6262                    }
    6363                }
    64                 if(i2==-1) sprintf(lptv->item.pszText,"%s %d(&H%X)",VarName,(DWORD64)pData,(DWORD64)pData);
    65                 else sprintf(lptv->item.pszText,"%s %d(&H%X) \"%s\"",VarName,(DWORD64)pData,(DWORD64)pData,temporary);
     64                if(i2==-1) sprintf(lptv->item.pszText,"%s %d(&H%X)",VarName,(ULONG_PTR)pData,(ULONG_PTR)pData);
     65                else sprintf(lptv->item.pszText,"%s %d(&H%X) \"%s\"",VarName,(ULONG_PTR)pData,(ULONG_PTR)pData,temporary);
    6666            }
    6767            else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
    … …  
    361361    if(!pUserProc) return;
    362362
    363     foreach( Variable *pVar, UserProc::CompilingUserProc().localVars ){
     363    foreach( Variable *pVar, pUserProc->localVars ){
    364364
    365365        //スコープ外の場合は無視
    … …  
    413413    //Thisポインタを取得
    414414    LONG_PTR pThis;
    415     const Variable *pVar = UserProc::CompilingUserProc().localVars.Find( "_System_LocalThis" );
     415    const Variable *pVar = pUserProc->localVars.Find( "_System_LocalThis" );
    416416    if( !pVar ){
    417417        return;
    … …  
    428428                pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
    429429                STRING_ARRAY,
    430                 (DWORD64)offset);
     430                (ULONG_PTR)offset);
    431431            tv.item.iImage=0;
    432432            tv.item.iSelectedImage=0;
    … …  
    559559    for(i3=0;i3<(int)pobj_dti->iProcLevel+1;i3++){
    560560        for(i2=0;i2<MaxLineInfoNum-1;i2++){
    561             if((DWORD64)(pLineInfo[i2].TopObp+ImageBase+MemPos_CodeSection)<=pobj_dti->lplpObp[i3]&&
    562                 pobj_dti->lplpObp[i3]<=(DWORD64)(pLineInfo[i2+1].TopObp+ImageBase+MemPos_CodeSection)) break;
     561            if((ULONG_PTR)(pLineInfo[i2].TopObp+ImageBase+MemPos_CodeSection)<=pobj_dti->lplpObp[i3]&&
     562                pobj_dti->lplpObp[i3]<=(ULONG_PTR)(pLineInfo[i2+1].TopObp+ImageBase+MemPos_CodeSection)) break;
    563563        }
    564564        if(i2==MaxLineInfoNum) pobj_dti->lpdwCp[i3]=-1;

  • BasicCompiler_Common/VariableOpe.cpp

    r76 r78  
    228228    ////////////////////
    229229    int i;
    230     i=pobj_DBTypeDef->check(TypeName);
     230    i=House::typeDefs.GetIndex(TypeName);
    231231    if(i!=-1){
    232         return GetTypeFixed(pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName,lpNum);
     232        *lpNum = House::typeDefs[i].GetBaseType().GetIndex();
     233        return House::typeDefs[i].GetBaseType().GetBasicType();
    233234    }
    234235
    … …  
    251252    return -1;
    252253}
    253 void GetOriginalTypeName(char *buffer){
     254/*
     255TODO: 消す(TypeDef関連の変更)
     256void GetOriginalTypeName_Old(char *buffer){
    254257    // TypeDefされた型に対して、オリジナルの型の名前に変更する
    255258
    … …  
    257260        if(buffer[1]==1&&(buffer[2]==ESC_FUNCTION||buffer[2]==ESC_SUB)) return;
    258261
    259         GetOriginalTypeName(buffer+1);
     262        GetOriginalTypeName_Old(buffer+1);
    260263        return;
    261264    }
    262265
    263266    int i;
    264     i=pobj_DBTypeDef->check(buffer);
     267    i=House::typeDefs.GetIndex(buffer);
    265268    if(i!=-1){
    266         lstrcpy(buffer,pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName);
    267         GetOriginalTypeName(buffer);
    268     }
    269 }
     269        lstrcpy(buffer,House::typeDefs[i].GetBaseName().c_str());
     270        GetOriginalTypeName_Old(buffer);
     271    }
     272}*/
    270273BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
    271274    if(PTR_LEVEL(type)){
    … …  
    309312        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
    310313        else{
    311             extern ProcPointer **ppProcPointer;
    312             if( ppProcPointer[lpIndex]->ReturnType().IsNull() )
     314            if( House::procPointers[lpIndex]->ReturnType().IsNull() )
    313315                lstrcpy(name,"*Sub");
    314316            else lstrcpy(name,"*Function");
    … …  
    988990            temporary[i2]=buffer[i];
    989991        }
     992        if(temporary[0]=='*'&&
     993            temporary[1]==1&&
     994            (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
     995            if(buffer[i]!='('){
     996                SetError(10,temporary,cp);
     997                return false;
     998            }
     999            i3=GetStringInPare(temporary+3,buffer+i);
     1000            i+=i3;
     1001            i2+=i3;
     1002
     1003            if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
     1004                temporary[i2++]=buffer[i++];
     1005                temporary[i2++]=buffer[i++];
     1006                for(;;i++,i2++){
     1007                    if(!IsVariableChar(buffer[i])){
     1008                        temporary[i2]=0;
     1009                        break;
     1010                    }
     1011                    temporary[i2]=buffer[i];
     1012                }
     1013            }
     1014        }
     1015
    9901016        if( !Type::StringToType( temporary, type ) ){
    9911017            SetError(3,temporary,cp);
    9921018            type.SetBasicType( DEF_LONG );
    993         }
    994 
    995         if( type.IsProcPtr() ){
    996             if(temporary[0]=='*'&&
    997                 temporary[1]==1&&
    998                 (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
    999                 if(buffer[i]!='('){
    1000                     SetError(10,temporary,cp);
    1001                     return false;
    1002                 }
    1003                 i3=GetStringInPare(temporary+3,buffer+i);
    1004                 i+=i3;
    1005                 i2+=i3;
    1006 
    1007                 if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
    1008                     temporary[i2++]=buffer[i++];
    1009                     temporary[i2++]=buffer[i++];
    1010                     for(;;i++,i2++){
    1011                         if(!IsVariableChar(buffer[i])){
    1012                             temporary[i2]=0;
    1013                             break;
    1014                         }
    1015                         temporary[i2]=buffer[i];
    1016                     }
    1017                 }
    1018             }
    1019             else{
    1020                 //TypeDefをする前のベース型を取得
    1021                 GetOriginalTypeName(temporary);
    1022             }
    1023 
    1024             if(temporary[3]!='('){
    1025                 SetError(10,temporary,cp);
    1026                 return false;
    1027             }
    1028 
    1029             //関数ポインタ
    1030             type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], cp) );
    10311019        }
    10321020

  • BasicCompiler_Common/VariableOpe.h

    r75 r78  
    1414int GetPtrType(int type);
    1515int GetTypeFixed(const char *TypeName,LONG_PTR *lpNum);
     16/*
     17TODO: 消す(TypeDef関連の変更)
     18void GetOriginalTypeName_Old(char *buffer);
    1619void GetOriginalTypeName(char *buffer);
     20*/
    1721BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
    1822bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member );

  • BasicCompiler_Common/WatchList.cpp

    r76 r78  
    338338    // ローカル変数
    339339    /////////////////
    340     const Variable *pVar = UserProc::CompilingUserProc().localVars.Find( VarName );
    341     if( pVar ){
    342         //ポインタ変数の場合
    343         if( pVar->IsPointer() ){
    344             if( !pVar->IsArray() ){
    345                 lstrcpy(lpPtrOffset,array);
    346                 array[0]=0;
    347             }
     340    if( UserProc::IsLocalAreaCompiling() ){
     341        const Variable *pVar = UserProc::CompilingUserProc().localVars.Find( VarName );
     342
     343        if( pVar ){
     344            //ポインタ変数の場合
     345            if( pVar->IsPointer() ){
     346                if( !pVar->IsArray() ){
     347                    lstrcpy(lpPtrOffset,array);
     348                    array[0]=0;
     349                }
     350            }
     351            else{
     352                if(lpPtrOffset[0]) return 0;
     353            }
     354
     355            pRelativeVar->offset = pVar->offset;
     356            if( pVar->IsRef() ){
     357                pRelativeVar->dwKind=VAR_REFLOCAL;
     358            }
     359            else{
     360                pRelativeVar->dwKind=VAR_LOCAL;
     361            }
     362            resultType = *pVar;
     363            isArray = pVar->IsArray();
     364            pSubScripts = pVar->GetSubScriptsPtr();
     365        }
     366    }
     367
     368    if(pobj_CompilingClass){
     369        ///////////////////////
     370        // クラスメンバの参照
     371        ///////////////////////
     372
     373        if(memicmp(variable,"This.",5)==0){
     374            //Thisオブジェクトのメンバを参照するとき
     375            SlideString(variable+5,-5);
     376            lstrcpy(VarName,variable);
    348377        }
    349378        else{
    350             if(lpPtrOffset[0]) return 0;
    351         }
    352 
    353         pRelativeVar->offset = pVar->offset;
    354         if( pVar->IsRef() ){
    355             pRelativeVar->dwKind=VAR_REFLOCAL;
    356         }
    357         else{
    358             pRelativeVar->dwKind=VAR_LOCAL;
    359         }
    360         resultType = *pVar;
    361         isArray = pVar->IsArray();
    362         pSubScripts = pVar->GetSubScriptsPtr();
    363     }
    364     else{
    365         if(pobj_CompilingClass){
    366             ///////////////////////
    367             // クラスメンバの参照
    368             ///////////////////////
    369 
    370             if(memicmp(variable,"This.",5)==0){
    371                 //Thisオブジェクトのメンバを参照するとき
    372                 SlideString(variable+5,-5);
    373                 lstrcpy(VarName,variable);
    374             }
    375             else{
    376                 //クラス内メンバを参照するとき（通常）
    377 
    378                 for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    379                     if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
    380                 }
    381                 if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
    382             }
    383 
    384             /////////////////////////////
    385             // thisポインタを取得
    386 
    387             extern HWND hDebugWnd;
    388             i2=(int)SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
    389             i2=pobj_dti->iProcLevel-i2;
    390 
    391             lpData=Debugging_GetThisPtrOffset(pobj_dti->lplpObp[i2]);
    392             if(!lpData){
    393                 //式エラー
    394                 return 0;
    395             }
    396             lpData+=pobj_dti->lplpSpBase[i2];
    397             if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&accessBytes)){
    398                 //メモリにアクセスできないとき
    399                 return -1;
    400             }
    401 
    402             pRelativeVar->dwKind=VAR_DIRECTMEM;
    403 
    404             i3=Debugging_GetMember(*pobj_CompilingClass,variable,pRelativeVar,resultType,1);
    405             if(i3==0){
    406                 //式エラー
    407                 return 0;
    408             }
    409             if(i3==-1){
    410                 //アクセスエラー
    411                 return -1;
    412             }
    413 
    414             return 1;
    415         }
     379            //クラス内メンバを参照するとき（通常）
     380
     381            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
     382                if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
     383            }
     384            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
     385        }
     386
     387        /////////////////////////////
     388        // thisポインタを取得
     389
     390        extern HWND hDebugWnd;
     391        i2=(int)SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
     392        i2=pobj_dti->iProcLevel-i2;
     393
     394        lpData=Debugging_GetThisPtrOffset(pobj_dti->lplpObp[i2]);
     395        if(!lpData){
     396            //式エラー
     397            return 0;
     398        }
     399        lpData+=pobj_dti->lplpSpBase[i2];
     400        if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&accessBytes)){
     401            //メモリにアクセスできないとき
     402            return -1;
     403        }
     404
     405        pRelativeVar->dwKind=VAR_DIRECTMEM;
     406
     407        i3=Debugging_GetMember(*pobj_CompilingClass,variable,pRelativeVar,resultType,1);
     408        if(i3==0){
     409            //式エラー
     410            return 0;
     411        }
     412        if(i3==-1){
     413            //アクセスエラー
     414            return -1;
     415        }
     416
     417        return 1;
     418    }
    416419
    417420NonClassMember:
    418421
     422    {
    419423        ///////////////////
    420424        // グローバル変数

  • BasicCompiler_Common/calculation.cpp

    r76 r78  
    502502
    503503                        Type tempType;
    504                         StaticCalculation(true, Parms,BaseType,&i64data,tempType);
     504                        StaticCalculation(enableerror, Parms,BaseType,&i64data,tempType);
    505505                        type[pnum] = tempType.GetBasicType();
    506506                        before_index[pnum] = tempType.GetIndex();

  • BasicCompiler_Common/common.h

    r77 r78  
    3535#include "../BasicCompiler_Common/BasicFixed.h"
    3636#include "../BasicCompiler_Common/NonVolatile.h"
    37 #include "../BasicCompiler_Common/TypeDef.h"
    3837#include "../BasicCompiler_Common/psapi.h"
    3938#include "../BasicCompiler_Common/BreakPoint.h"
    … …  
    162161// プロシージャ管理用のクラス
    163162#include "Procedure.h"
     163
     164// コンパイラが必要とするデータハウス
     165#include <House.h>
    164166
    165167
    … …  
    441443void DeleteSubInfo(UserProc **ppSubHash,char **ppMacroNames,int MacroNum);
    442444void DeleteDeclareInfo(void);
    443 int AddProcPtrInfo( char *buffer, DWORD dwProcType, int nowLine );
     445int AddProcPtrInfo( const string &typeExpression, int nowLine );
    444446void DeleteProcPtrInfo(void);
    445447
Note: See TracChangeset for help on using the changeset viewer.