Ticket #8512: gob_cleanup.patch

File gob_cleanup.patch, 39.1 KB (added by wjp, 18 years ago)

gob_cleanup.patch

  • cdrom.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/cdrom.cpp,v
retrieving revision 1.8
diff -u -r1.8 cdrom.cpp
     
    8686                _vm->_dataio->seekData(handle, pos, SEEK_CUR);
    8787        }
    8888
    89         _LICbuffer = (byte *)malloc(_numTracks * 22);
     89        _LICbuffer = new byte[_numTracks * 22];
    9090        _vm->_dataio->readData(handle, (char *)_LICbuffer, _numTracks * 22);
    9191
    9292        _vm->_dataio->closeData(handle);
    9393}
    9494
    9595void CDROM::freeLICbuffer(void) {
    96         free(_LICbuffer);
     96        delete[] _LICbuffer;
    9797        _LICbuffer = 0;
    9898}
    9999

  • dataio.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/dataio.cpp,v
retrieving revision 1.14
diff -u -r1.14 dataio.cpp
     
    185185        char path[128];
    186186        int16 i;
    187187        int16 file;
    188         struct ChunkDesc *dataDesc;
     188        ChunkDesc *dataDesc;
    189189
    190190        strcpy(path, src);
    191191        for (i = 0; path[i] != '.' && path[i] != 0; i++);
    … …  
    207207
    208208        debug(7, "DataChunks: %d [for %s]", _vm->_global->_numDataChunks[file], path);
    209209
    210         _vm->_global->_dataFiles[file] = dataDesc =
    211             (struct ChunkDesc *)malloc(sizeof(struct ChunkDesc) *
    212             _vm->_global->_numDataChunks[file]);
     210        dataDesc = new ChunkDesc[_vm->_global->_numDataChunks[file]];
     211        _vm->_global->_dataFiles[file] = dataDesc;
    213212
    214213        for (i = 0; i < _vm->_global->_numDataChunks[file]; i++) {
    215214                file_getHandle(_vm->_global->_dataFileHandles[file])->read(dataDesc[i].chunkName, 13);
    … …  
    230229        int16 file;
    231230        for (file = MAX_DATA_FILES - 1; file >= 0; file--) {
    232231                if (_vm->_global->_dataFiles[file] != 0) {
    233                         free(_vm->_global->_dataFiles[file]);
     232                        delete[] _vm->_global->_dataFiles[file];
    234233                        _vm->_global->_dataFiles[file] = 0;
    235234                        file_getHandle(_vm->_global->_dataFileHandles[file])->close();
    236235                        return;
    … …  
    254253        if (chunk == -1)
    255254                return 0;
    256255
    257         unpackBuf = (char *)malloc(realSize);
     256        unpackBuf = new char[realSize];
    258257        if (unpackBuf == 0)
    259258                return 0;
    260259
    261         packBuf = (char *)malloc(_vm->_global->_packedSize);
     260        packBuf = new char[_vm->_global->_packedSize];
    262261        if (packBuf == 0) {
    263                 free(unpackBuf);
     262                delete[] unpackBuf;
    264263                return 0;
    265264        }
    266265
    … …  
    274273        readChunk(chunk, ptr, sizeLeft);
    275274        freeChunk(chunk);
    276275        _vm->_pack->unpackData(packBuf, unpackBuf);
    277         free(packBuf);
     276
     277        delete[] packBuf;
    278278        return unpackBuf;
    279279}
    280280
    … …  
    346346                return data;
    347347
    348348        size = getDataSize(path);
    349         data = (char *)malloc(size);
     349        data = new char[size];
    350350        if (data == 0)
    351351                return 0;
    352352

  • draw.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/draw.cpp,v
retrieving revision 1.21
diff -u -r1.21 draw.cpp
     
    417417                                    _destSpriteX + _spriteRight - 1,
    418418                                    _destSpriteY + _spriteBottom - 1);
    419419                        }
    420                         free(dataBuf);
     420                        delete[] dataBuf;
    421421                        break;
    422422                }
    423423                // Load from .TOT resources

  • draw.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/draw.h,v
retrieving revision 1.10
diff -u -r1.10 draw.h
     
    3333
    3434class Draw {
    3535public:
    36         typedef struct FontToSprite {
     36        struct FontToSprite {
    3737                int8 sprite;
    3838                int8 base;
    3939                int8 width;
    4040                int8 height;
    4141                FontToSprite() : sprite(0), base(0), width(0), height() {}
    42         } FontToSprite;
     42        };
    4343
    4444        int16 _fontIndex;
    4545        int16 _spriteLeft;

  • game.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/game.cpp,v
retrieving revision 1.35
diff -u -r1.35 game.cpp
     
    141141
    142142        debug(7, "off: %ld size: %ld", offset, tableSize);
    143143        _vm->_dataio->seekData(handle, offset + tableSize, SEEK_SET);
     144        // CHECKME: is the below correct?
    144145        if (isPacked)
    145                 dataBuf = (char *)malloc(size);
     146                dataBuf = new char[size];
    146147        else
    147                 dataBuf = (char *)malloc(size);
     148                dataBuf = new char[size];
    148149
    149150        dataPtr = dataBuf;
    150151        while (size > 32000) {
    … …  
    161162
    162163        if (isPacked != 0) {
    163164                packedBuf = dataBuf;
    164                 dataBuf = (char *)malloc(READ_LE_UINT32(packedBuf));
     165                dataBuf = new char[READ_LE_UINT32(packedBuf)];
    165166                _vm->_pack->unpackData(packedBuf, dataBuf);
    166                 free(packedBuf);
     167                delete[] packedBuf;
    167168        }
    168169
    169170        return dataBuf;
    … …  
    229230                        size++;
    230231        }
    231232
    232         destPtr = (Collision *)malloc(size * sizeof(Collision));
     233        destPtr = new Collision[size];
    233234        _collStack[_collStackSize] = destPtr;
    234235        _collStackElemSizes[_collStackSize] = size;
    235236        _collStackSize++;
    … …  
    392393void Game::loadSound(int16 slot, char *dataPtr) {
    393394        Snd::SoundDesc *soundDesc;
    394395
    395         soundDesc = (Snd::SoundDesc *)malloc(sizeof(Snd::SoundDesc));
     396        soundDesc = new Snd::SoundDesc;
    396397
    397398        _soundSamples[slot] = soundDesc;
    398399
    … …  
    437438                return;
    438439
    439440        if (_soundFromExt[slot] == 1) {
    440                 free(_soundSamples[slot]->data - 6);
     441                delete[] (_soundSamples[slot]->data - 6);
    441442                _soundFromExt[slot] = 0;
    442443        }
    443444
    444         free(_soundSamples[slot]);
     445        delete _soundSamples[slot];
    445446        _soundSamples[slot] = 0;
    446447}
    447448
    … …  
    16871688        count = FROM_LE_16(count);
    16881689
    16891690        _vm->_dataio->seekData(_extHandle, 0, 0);
    1690         _extTable = (ExtTable *)malloc(sizeof(ExtTable)
    1691             + sizeof(ExtItem) * count);
     1691        _extTable = new ExtTable;
     1692        _extTable->items = 0;
     1693        if (count)
     1694                _extTable->items = new ExtItem[count];
    16921695
    16931696        _vm->_dataio->readData(_extHandle, (char *)&_extTable->itemsCount, 2);
    16941697        _extTable->itemsCount = FROM_LE_16(_extTable->itemsCount);
    … …  
    18551858                        _vm->_global->_inter_animDataSize = READ_LE_UINT16((char *)_totFileData + 0x38);
    18561859                        if (_vm->_global->_inter_variables == 0) {
    18571860                                variablesCount = READ_LE_UINT32((char *)_totFileData + 0x2c);
    1858                                 _vm->_global->_inter_variables = (char *)malloc(variablesCount * 4);
     1861                                _vm->_global->_inter_variables = new char[variablesCount * 4];
    18591862                                for (i = 0; i < variablesCount; i++)
    18601863                                        WRITE_VAR(i, 0);
    18611864                        }
    … …  
    18771880
    18781881                        variablesCount = READ_LE_UINT32((char *)_totFileData + 0x2c);
    18791882                        _vm->_draw->blitInvalidated();
    1880                         free(_totFileData);
     1883                        delete[] _totFileData;
    18811884                        _totFileData = 0;
    18821885
    18831886                        if (needTextFree)
    1884                                 free(_totTextData);
     1887                                delete[] _totTextData;
    18851888                        _totTextData = 0;
    18861889
    18871890                        if (needFreeResTable)
    1888                                 free(_totResourceTable);
     1891                                delete[] _totResourceTable;
    18891892                        _totResourceTable = 0;
    18901893
    1891                         free(_imFileData);
     1894                        delete[] _imFileData;
    18921895                        _imFileData = 0;
    18931896
    1894                         free(_extTable);
     1897                        if (_extTable)
     1898                                delete[] _extTable->items;
     1899                        delete _extTable;
    18951900                        _extTable = 0;
    18961901
    18971902                        if (_extHandle >= 0)
    … …  
    19311936}
    19321937
    19331938void Game::start(void) {
    1934         _collisionAreas = (Collision *)malloc(250 * sizeof(Collision));
     1939        _collisionAreas = new Collision[250];
    19351940        prepareStart();
    19361941        playTot(0);
    19371942
    1938         free(_collisionAreas);
     1943        delete[] _collisionAreas;
    19391944
    19401945        _vm->_video->freeSurfDesc(_vm->_draw->_cursorSprites);
    19411946        _vm->_video->freeSurfDesc(_vm->_draw->_cursorBack);

  • game.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/game.h,v
retrieving revision 1.9
diff -u -r1.9 game.h
     
    3131
    3232#pragma START_PACK_STRUCTS
    3333#define szGame_TotResItem (4 + 2 + 2 + 2)
    34         typedef struct Collision {
     34        struct Collision {
    3535                int16 id;
    3636                int16 left;
    3737                int16 top;
    … …  
    4141                int16 key;
    4242                int16 funcEnter;
    4343                int16 funcLeave;
    44         } GCC_PACK Collision;
     44        } GCC_PACK;
    4545
    46         typedef struct TotResItem {
     46        struct TotResItem {
    4747                int32 offset;   // if > 0, then offset from end of resource table.
    4848                                                // If < 0, then -offset-1 is index in .IM file table
    4949                int16 size;
    5050                int16 width;
    5151                int16 height;
    52         } GCC_PACK TotResItem;
     52        } GCC_PACK;
    5353
    5454#define szGame_TotResTable (2 + 1)
    55         typedef struct TotResTable {
     55        struct TotResTable {
    5656                int16 itemsCount;
    5757                byte unknown;
    5858                TotResItem items[1];
    59         } GCC_PACK TotResTable;
     59        } GCC_PACK;
    6060
    6161#define szGame_ExtItem (4 + 2 + 2 + 2)
    62         typedef struct ExtItem {
     62        struct ExtItem {
    6363                int32 offset;           // offset from the table end
    6464                uint16 size;
    6565                int16 width;            // width&0x7fff - width, width&0x8000 - pack flag
    6666                int16 height;           // not zero
    67         } GCC_PACK ExtItem;
     67        } GCC_PACK;
    6868
    6969#define szGame_ExtTable (2 + 1)
    70         typedef struct ExtTable {
     70        struct ExtTable {
    7171                int16 itemsCount;
    7272                byte unknown;
    73                 ExtItem items[1];
    74         } GCC_PACK ExtTable;
     73                ExtItem* items;
     74        } GCC_PACK;
    7575
    7676#define szGame_TotTextItem (2 + 2)
    77         typedef struct TotTextItem {
     77        struct TotTextItem {
    7878                int16 offset;
    7979                int16 size;
    80         } GCC_PACK TotTextItem;
     80        } GCC_PACK;
    8181
    8282#define szGame_TotTextTable (2)
    83         typedef struct TotTextTable {
     83        struct TotTextTable {
    8484                int16 itemsCount;
    8585                TotTextItem items[1];
    86         } GCC_PACK TotTextTable;
     86        } GCC_PACK;
    8787
    88         typedef struct InputDesc {
     88        struct InputDesc {
    8989                int16 fontIndex;
    9090                int16 backColor;
    9191                int16 frontColor;
    9292                char *ptr;
    93         } GCC_PACK InputDesc;
     93        } GCC_PACK;
    9494#pragma END_PACK_STRUCTS
    9595
    9696        TotResTable *_totResourceTable;

  • global.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/global.cpp,v
retrieving revision 1.12
diff -u -r1.12 global.cpp
     
    8888
    8989        _oldMode = 3;
    9090        _dontSetPalette = 0;
    91         _curPrimaryDesc = 0;
    92         _allocatedPrimary = 0;
    9391        _pPrimarySurfDesc = 0;
    9492
    9593        _pPaletteDesc = 0;
    … …  
    146144
    147145        _inter_mouseX = 0;
    148146        _inter_mouseY = 0;
    149 
    150         _tmpPalBuffer = 0;
    151147}
    152148
    153149} // End of namespace Gob

  • global.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/global.h,v
retrieving revision 1.11
diff -u -r1.11 global.h
     
    134134
    135135        int16 _setAllPalette;
    136136
    137         Video::SurfaceDesc *_curPrimaryDesc;
    138         Video::SurfaceDesc *_allocatedPrimary;
    139         Video::SurfaceDesc_t _primarySurfDesc;
     137        Video::SurfaceDesc _primarySurfDesc;
    140138        Video::SurfaceDesc *_pPrimarySurfDesc;
    141139
    142140        int16 _oldMode;
    … …  
    163161        int16 _inter_mouseX;
    164162        int16 _inter_mouseY;
    165163
    166         char *_tmpPalBuffer;
    167 
    168164        Global(GobEngine *vm);
    169165
    170166protected:

  • gob.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/gob.h,v
retrieving revision 1.18
diff -u -r1.18 gob.h
     
    7373        GF_MAC = 1 << 5
    7474};
    7575
    76 typedef struct GobGameSettings {
     76struct GobGameSettings {
    7777        const char *gameid;
    7878        const char *description;
    7979        uint32 features;
    … …  
    8282                GameSettings dummy = { gameid, description, features };
    8383                return dummy;
    8484        }
    85 } GobGameSettings;
     85};
    8686
    8787class GobEngine : public Engine {
    8888        void errorString(const char *buf_input, char *buf_output);

  • goblin.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/goblin.cpp,v
retrieving revision 1.33
diff -u -r1.33 goblin.cpp
     
    177177}
    178178
    179179void Goblin::initList(void) {
    180         _objList = (Util::List *) malloc(sizeof(Util::List));
     180        _objList = new Util::List;
    181181        _objList->pHead = 0;
    182182        _objList->pTail = 0;
    183183}
    … …  
    18481848                }
    18491849
    18501850                delete[] _goblins[i]->stateMach;
    1851                 free(_goblins[i]);
     1851                delete _goblins[i];
    18521852                _goblins[i] = 0;
    18531853        }
    18541854
    … …  
    18661866                }
    18671867
    18681868                delete[] _objects[i]->stateMach;
    1869                 free(_objects[i]);
     1869                delete _objects[i];
    18701870                _objects[i] = 0;
    18711871        }
    18721872}

  • goblin.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/goblin.h,v
retrieving revision 1.11
diff -u -r1.11 goblin.h
     
    3434class Goblin {
    3535public:
    3636#pragma START_PACK_STRUCTS
    37         typedef struct Gob_State {
     37        struct Gob_State {
    3838                int16 animation;// +0h
    3939                int16 layer;    // +2h
    4040                int16 unk0;             // +4h
    … …  
    4343                int16 freq;             // +Ah, high/low byte * 100 - frequency
    4444                int16 repCount; // +Ch high/low byte - repeat count
    4545                int16 sndFrame;         // +Eh
    46         } GCC_PACK Gob_State;
     46        } GCC_PACK;
    4747
    4848        typedef Gob_State *Gob_PState;
    4949
    5050        typedef Gob_PState Gob_StateLine[6];
    5151
    52         typedef struct Gob_Object {
     52        struct Gob_Object {
    5353                int16 animation;        // +0h
    5454                int16 state;            // +2h
    5555                int16 stateColumn;      // +4h
    … …  
    8282                char multObjIndex;      // +37h, from which play mult animations
    8383                char unk14;                     // +38h
    8484                char visible;           // +39h
    85         } GCC_PACK Gob_Object;
     85        } GCC_PACK;
    8686
    87         typedef struct Gob_Pos {
     87        struct Gob_Pos {
    8888                char x;
    8989                char y;
    90         } GCC_PACK Gob_Pos;
     90        } GCC_PACK;
    9191#pragma END_PACK_STRUCTS
    9292
    9393        Util::List *_objList;

  • init.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/init.cpp,v
retrieving revision 1.17
diff -u -r1.17 init.cpp
     
    104104                _vm->_gtimer->disableTimer();
    105105
    106106        _vm->_video->freeDriver();
    107         if (_vm->_global->_curPrimaryDesc != 0) {
    108                 _vm->_video->freeSurfDesc(_vm->_global->_curPrimaryDesc);
    109                 _vm->_video->freeSurfDesc(_vm->_global->_allocatedPrimary);
    110                 _vm->_global->_allocatedPrimary = 0;
    111                 _vm->_global->_curPrimaryDesc = 0;
    112         }
     107        _vm->_video->freeSurfDesc(_vm->_global->_pPrimarySurfDesc);
    113108        _vm->_global->_pPrimarySurfDesc = 0;
     109
    114110        if (_vm->_snd->_cleanupFunc != 0 && _vm->_snd->_playingSound != 0) {
    115111                (*_vm->_snd->_cleanupFunc) (0);
    116112                _vm->_snd->_cleanupFunc = 0;
    … …  
    172168        _vm->_game->_totFileData = 0;
    173169        _vm->_game->_totResourceTable = 0;
    174170        _vm->_global->_inter_variables = 0;
    175         _palDesc = (Video::PalDesc *)malloc(12);
     171        _palDesc = new Video::PalDesc;
    176172
    177173        if (_vm->_global->_videoMode != 0x13)
    178174                error("initGame: Only 0x13 video mode is supported!");
    … …  
    224220                        if (infPtr == infEnd)
    225221                                break;
    226222                }
    227 
    228                 free(infBuf);
     223                delete[] infBuf;
    229224        }
    230225
    231226        if (totName != 0) {
    … …  
    244239                varsCount = FROM_LE_32(varsCount);
    245240                _vm->_dataio->closeData(handle);
    246241
    247                 _vm->_global->_inter_variables = (char *)malloc(varsCount * 4);
     242                _vm->_global->_inter_variables = new char[varsCount * 4];
    248243                memset(_vm->_global->_inter_variables, 0, varsCount * 4);
    249244
    250245                strcpy(_vm->_game->_curTotFile, buffer);
    … …  
    256251                _vm->_cdrom->stopPlaying();
    257252                _vm->_cdrom->freeLICbuffer();
    258253
    259                 free(_vm->_global->_inter_variables);
    260                 free(_vm->_game->_totFileData);
    261                 free(_vm->_game->_totTextData);
    262                 free(_vm->_game->_totResourceTable);
     254                delete[] _vm->_global->_inter_variables;
     255                delete[] _vm->_game->_totFileData;
     256                delete[] _vm->_game->_totTextData;
     257                delete[] _vm->_game->_totResourceTable;
    263258        }
    264259
    265260        for (i = 0; i < 4; i++) {
    … …  
    267262                        _vm->_util->freeFont(_vm->_draw->_fonts[i]);
    268263        }
    269264
    270         free(_palDesc);
     265        delete _palDesc;
    271266        _vm->_dataio->closeDataFile();
    272267        _vm->_video->initPrimary(-1);
    273268        cleanup();

  • map.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/map.cpp,v
retrieving revision 1.23
diff -u -r1.23 map.cpp
     
    512512
    513513        _vm->_goblin->_gobsCount = loadFromAvo_LE_UINT16();
    514514        for (i = 0; i < _vm->_goblin->_gobsCount; i++) {
    515                 _vm->_goblin->_goblins[i] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
     515                _vm->_goblin->_goblins[i] = new Goblin::Gob_Object;
    516516
    517517                _vm->_goblin->_goblins[i]->xPos = READ_LE_UINT16(savedPtr2);
    518518                savedPtr2 += 2;
    … …  
    620620
    621621        _vm->_goblin->_objCount = loadFromAvo_LE_UINT16();
    622622        for (i = 0; i < _vm->_goblin->_objCount; i++) {
    623                 _vm->_goblin->_objects[i] =
    624                     (Goblin::Gob_Object *) malloc(sizeof(Goblin::Gob_Object));
     623                _vm->_goblin->_objects[i] = new Goblin::Gob_Object;
    625624
    626625                _vm->_goblin->_objects[i]->xPos = READ_LE_UINT16(savedPtr3);
    627626                savedPtr3 += 2;
    … …  
    681680                delete[] tempstatedata;
    682681        }
    683682
    684         _vm->_goblin->_objects[10] = (Goblin::Gob_Object *)malloc(sizeof(Goblin::Gob_Object));
     683        _vm->_goblin->_objects[10] = new Goblin::Gob_Object;
    685684        memset(_vm->_goblin->_objects[10], 0, sizeof(Goblin::Gob_Object));
    686685
    687686        _vm->_goblin->_objects[10]->stateMach = new Goblin::Gob_StateLine[40];
    … …  
    728727                strcpy(sndNames[i], buf);
    729728        }
    730729
    731         free(dataBuf);
     730        delete[] dataBuf;
    732731
    733732        _vm->_goblin->_soundData[14] = _vm->_snd->loadSoundData("diamant1.snd");
    734733

  • map.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/map.h,v
retrieving revision 1.14
diff -u -r1.14 map.h
     
    4545
    4646#pragma START_PACK_STRUCTS
    4747
    48         typedef struct Point {
     48        struct Point {
    4949                int16 x;
    5050                int16 y;
    51         } GCC_PACK Point;
     51        } GCC_PACK;
    5252
    5353#define szMap_ItemPos 3
    5454
    55         typedef struct ItemPos {
     55        struct ItemPos {
    5656                int8 x;
    5757                int8 y;
    5858                int8 orient;            // ??
    59         } GCC_PACK ItemPos;
     59        } GCC_PACK;
    6060
    6161#pragma END_PACK_STRUCTS
    6262

  • mult.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/mult.cpp,v
retrieving revision 1.18
diff -u -r1.18 mult.cpp
     
    437437        animDataVar = _vm->_parse->parseVarIndex();
    438438
    439439        if (_objects == 0) {
    440                 _renderData = (int16 *)malloc(sizeof(int16) * _objCount * 9);
    441                 _objects = (Mult_Object *)malloc(sizeof(Mult_Object) * _objCount);
     440                _renderData = new int16[_objCount * 9];
     441                _objects = new Mult_Object[_objCount];
    442442
    443443                for (i = 0; i < _objCount; i++) {
    444444                        _objects[i].pPosX = (int32 *)(_vm->_global->_inter_variables + i * 4 + (posXVar / 4) * 4);
    … …  
    487487        if (_vm->_anim->_animSurf != 0)
    488488                _vm->_video->freeSurfDesc(_vm->_anim->_animSurf);
    489489
    490         free(_objects);
    491         free(_renderData);
     490        delete[] _objects;
     491        delete[] _renderData;
    492492
    493493        _objects = 0;
    494494        _renderData = 0;
    … …  
    860860                        _vm->_anim->_areaHeight = 200;
    861861                        _objCount = 4;
    862862
    863                         _objects = (Mult_Object *)malloc(sizeof(Mult_Object) * _objCount);
    864                         _renderData = (int16 *)malloc(sizeof(int16) * 9 * _objCount);
     863                        _objects = new Mult_Object[_objCount];
     864                        _renderData = new int16[9 * _objCount];
    865865
    866                         _animArrayX = (int32 *)malloc(sizeof(int32) * _objCount);
    867                         _animArrayY = (int32 *)malloc(sizeof(int32) * _objCount);
     866                        _animArrayX = new int32[_objCount];
     867                        _animArrayY = new int32[_objCount];
    868868
    869                         _animArrayData = (Mult_AnimData *)malloc(sizeof(Mult_AnimData) * _objCount);
     869                        _animArrayData = new Mult_AnimData[_objCount];
    870870
    871871                        for (_counter = 0; _counter < _objCount; _counter++) {
    872872                                multObj = &_objects[_counter];
    … …  
    940940
    941941        if (stopNoClear == 0) {
    942942                if (_animDataAllocated) {
    943                         free(_objects);
     943                        delete[] _objects;
    944944                        _objects = 0;
    945945
    946                         free(_renderData);
     946                        delete[] _renderData;
    947947                        _renderData = 0;
    948948
    949                         free(_animArrayX);
     949                        delete[] _animArrayX;
    950950                        _animArrayX = 0;
    951951
    952                         free(_animArrayY);
     952                        delete[] _animArrayY;
    953953                        _animArrayY = 0;
    954954
    955                         free(_animArrayData);
     955                        delete[] _animArrayData;
    956956                        _animArrayData = 0;
    957957
    958958                        if (_vm->_anim->_animSurf)
    … …  
    10201020        _staticKeysCount = READ_LE_UINT16(_dataPtr);
    10211021        _dataPtr += 2;
    10221022
    1023         _staticKeys = (Mult_StaticKey *)malloc(sizeof(Mult_StaticKey) *
    1024             _staticKeysCount);
     1023        _staticKeys = new Mult_StaticKey[_staticKeysCount];
    10251024        for (i = 0; i < _staticKeysCount; i++, _dataPtr += 4) {
    10261025                _staticKeys[i].frame = (int16)READ_LE_UINT16(_dataPtr);
    10271026                _staticKeys[i].layer = (int16)READ_LE_UINT16(_dataPtr + 2);
    … …  
    10311030                _animKeysCount[j] = READ_LE_UINT16(_dataPtr);
    10321031                _dataPtr += 2;
    10331032
    1034                 _animKeys[j] = (Mult_AnimKey *) malloc(sizeof(Mult_AnimKey) * _animKeysCount[j]);
     1033                _animKeys[j] = new Mult_AnimKey[_animKeysCount[j]];
    10351034                for (i = 0; i < _animKeysCount[j]; i++, _dataPtr += 10) {
    10361035                        _animKeys[j][i].frame = (int16)READ_LE_UINT16(_dataPtr);
    10371036                        _animKeys[j][i].layer = (int16)READ_LE_UINT16(_dataPtr + 2);
    … …  
    10521051
    10531052        _palFadeKeysCount = READ_LE_UINT16(_dataPtr);
    10541053        _dataPtr += 2;
    1055         _palFadeKeys = (Mult_PalFadeKey *)malloc(sizeof(Mult_PalFadeKey) * _palFadeKeysCount);
     1054        _palFadeKeys = new Mult_PalFadeKey[_palFadeKeysCount];
    10561055
    10571056        for (i = 0; i < _palFadeKeysCount; i++, _dataPtr += 7) {
    10581057                _palFadeKeys[i].frame = (int16)READ_LE_UINT16(_dataPtr);
    … …  
    10641063        _palKeysCount = READ_LE_UINT16(_dataPtr);
    10651064        _dataPtr += 2;
    10661065
    1067         _palKeys = (Mult_PalKey *)malloc(sizeof(Mult_PalKey) * _palKeysCount);
     1066        _palKeys = new Mult_PalKey[_palKeysCount];
    10681067        for (i = 0; i < _palKeysCount; i++, _dataPtr += 80) {
    10691068                _palKeys[i].frame = (int16)READ_LE_UINT16(_dataPtr);
    10701069                _palKeys[i].cmd = (int16)READ_LE_UINT16(_dataPtr + 2);
    … …  
    10791078
    10801079        _textKeysCount = READ_LE_UINT16(_dataPtr);
    10811080        _dataPtr += 2;
    1082         _textKeys = (Mult_TextKey *) malloc(sizeof(Mult_TextKey) * _textKeysCount);
     1081        _textKeys = new Mult_TextKey[_textKeysCount];
    10831082
    10841083        for (i = 0; i < _textKeysCount; i++, _dataPtr += 28) {
    10851084                _textKeys[i].frame = (int16)READ_LE_UINT16(_dataPtr);
    … …  
    10941093        _sndKeysCount = READ_LE_UINT16(_dataPtr);
    10951094        _dataPtr += 2;
    10961095
    1097         _sndKeys = (Mult_SndKey *)malloc(sizeof(Mult_SndKey) * _sndKeysCount);
     1096        _sndKeys = new Mult_SndKey[_sndKeysCount];
    10981097        for (i = 0; i < _sndKeysCount; i++) {
    10991098                _sndKeys[i].frame = (int16)READ_LE_UINT16(_dataPtr);
    11001099                _sndKeys[i].cmd = (int16)READ_LE_UINT16(_dataPtr + 2);
    … …  
    11491148        staticCount = _dataPtr[0];
    11501149        animCount = _dataPtr[1];
    11511150
    1152         free(_dataPtr);
     1151        delete[] _dataPtr;
    11531152
    11541153        staticCount++;
    11551154        animCount++;
    … …  
    11641163                        _vm->_scenery->freeAnim(_animIndices[i]);
    11651164        }
    11661165
    1167         free(_staticKeys);
     1166        delete[] _staticKeys;
    11681167
    11691168        for (i = 0; i < 4; i++)
    1170                 free(_animKeys[i]);
     1169                delete[] _animKeys[i];
    11711170
    1172         free(_palFadeKeys);
    1173         free(_palKeys);
    1174         free(_textKeys);
     1171        delete[] _palFadeKeys;
     1172        delete[] _palKeys;
     1173        delete[] _textKeys;
    11751174
    11761175        for (i = 0; i < _sndSlotsCount; i++) {
    11771176                _vm->_game->freeSoundSlot(19 - i);
    11781177        }
    11791178
    1180         free(_sndKeys);
     1179        delete[] _sndKeys;
    11811180
    11821181        _multData = 0;
    11831182
    11841183        if (_animDataAllocated != 0) {
    1185                 free(_objects);
     1184                delete[] _objects;
    11861185                _objects = 0;
    11871186
    1188                 free(_renderData);
     1187                delete[] _renderData;
    11891188                _renderData = 0;
    11901189
    1191                 free(_animArrayX);
     1190                delete[] _animArrayX;
    11921191                _animArrayX = 0;
    11931192
    1194                 free(_animArrayY);
     1193                delete[] _animArrayY;
    11951194                _animArrayY = 0;
    11961195
    1197                 free(_animArrayData);
     1196                delete[] _animArrayData;
    11981197                _animArrayData = 0;
    11991198
    12001199                if (_vm->_anim->_animSurf)

  • mult.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/mult.h,v
retrieving revision 1.9
diff -u -r1.9 mult.h
     
    2929class Mult {
    3030public:
    3131#pragma START_PACK_STRUCTS
    32         typedef struct Mult_AnimData {
     32        struct Mult_AnimData {
    3333                int8 animation;
    3434                int8 layer;
    3535                int8 frame;
    … …  
    4343                int8 newAnimation;
    4444                byte intersected;
    4545                int8 newCycle;
    46         } GCC_PACK Mult_AnimData;
     46        } GCC_PACK;
    4747
    48         typedef struct Mult_Object {
     48        struct Mult_Object {
    4949                int32 *pPosX;
    5050                int32 *pPosY;
    5151                Mult_AnimData *pAnimData;
    … …  
    5454                int16 lastRight;
    5555                int16 lastTop;
    5656                int16 lastBottom;
    57         } Mult_Object;
     57        };
    5858
    59         // Mult
    60         typedef struct Mult_StaticKey {
     59        struct Mult_StaticKey {
    6160                int16 frame;
    6261                int16 layer;
    63         } GCC_PACK Mult_StaticKey;
     62        } GCC_PACK;
    6463
    65         typedef struct Mult_AnimKey {
     64        struct Mult_AnimKey {
    6665                int16 frame;
    6766                int16 layer;
    6867                int16 posX;
    6968                int16 posY;
    7069                int16 order;
    71         } GCC_PACK Mult_AnimKey;
     70        } GCC_PACK;
    7271
    73         typedef struct Mult_TextKey {
     72        struct Mult_TextKey {
    7473                int16 frame;
    7574                int16 cmd;
    7675                int16 unknown0[9];
    7776                int16 index;
    7877                int16 unknown1[2];
    79         } GCC_PACK Mult_TextKey;
     78        } GCC_PACK;
    8079
    81         typedef struct Mult_PalKey {
     80        struct Mult_PalKey {
    8281                int16 frame;
    8382                int16 cmd;
    8483                int16 rates[4];
    8584                int16 unknown0;
    8685                int16 unknown1;
    8786                int8 subst[16][4];
    88         } GCC_PACK Mult_PalKey;
     87        } GCC_PACK;
    8988
    90         typedef struct Mult_PalFadeKey {
     89        struct Mult_PalFadeKey {
    9190                int16 frame;
    9291                int16 fade;
    9392                int16 palIndex;
    9493                int8 flag;
    95         } GCC_PACK Mult_PalFadeKey;
     94        } GCC_PACK;
    9695
    97         typedef struct Mult_SndKey {
     96        struct Mult_SndKey {
    9897                int16 frame;
    9998                int16 cmd;
    10099                int16 freq;
    … …  
    102101                int16 repCount;
    103102                int16 resId;
    104103                int16 soundIndex;
    105         } GCC_PACK Mult_SndKey;
     104        } GCC_PACK;
    106105#pragma END_PACK_STRUCTS
    107106
    108107        // Globals

  • pack.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/pack.cpp,v
retrieving revision 1.8
diff -u -r1.8 pack.cpp
     
    4040        realSize = READ_LE_UINT32(sourceBuf);
    4141        counter = READ_LE_UINT32(sourceBuf);
    4242
    43         tmpBuf = (byte *)malloc(4114);
     43        tmpBuf = new byte[4114];
    4444
    4545        /*
    4646         * Can use assembler unpacker for small blocks - for speed.
    … …  
    9191                                *dest++ = tmpBuf[(off + i) % 4096];
    9292                                counter--;
    9393                                if (counter == 0) {
    94                                         free(tmpBuf);
     94                                        delete[] tmpBuf;
    9595                                        return realSize;
    9696                                }
    9797                                tmpBuf[tmpIndex] = tmpBuf[(off + i) % 4096];
    … …  
    100100                        }
    101101                }
    102102        }
    103         free(tmpBuf);
     103        delete[] tmpBuf;
    104104        return realSize;
    105105}
    106106

  • palanim.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/palanim.cpp,v
retrieving revision 1.15
diff -u -r1.15 palanim.cpp
     
    186186
    187187        if (allColors == 0) {
    188188                do {
    189                         if (_vm->_global->_tmpPalBuffer == 0)
    190                                 _vm->_video->waitRetrace(_vm->_global->_videoMode);
     189                        _vm->_video->waitRetrace(_vm->_global->_videoMode);
    191190
    192191                        stop = fadeStep(0);
    193192
    … …  
    222221                else
    223222                        _vm->_util->clearPalette();
    224223        }
    225 
    226         free(_vm->_global->_tmpPalBuffer);
    227         _vm->_global->_tmpPalBuffer = 0;
    228224}
    229225
    230226}                               // End of namespace Gob

  • scenery.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/scenery.cpp,v
retrieving revision 1.25
diff -u -r1.25 scenery.cpp
     
    116116        ptr->layersCount = (int16)READ_LE_UINT16(dataPtr);
    117117        dataPtr += 2;
    118118
    119         ptr->layers = (StaticLayer **)malloc(sizeof(StaticLayer *) * ptr->layersCount);
    120         ptr->pieces = (PieceDesc **)malloc(sizeof(PieceDesc *) * picsCount);
    121         ptr->piecesFromExt = (int8 *)malloc(picsCount);
     119        ptr->layers = new StaticLayer*[ptr->layersCount];
     120        ptr->pieces = new PieceDesc*[picsCount];
     121        ptr->piecesFromExt = new int8[picsCount];
    122122
    123123        for (i = 0; i < ptr->layersCount; i++) {
    124124                offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[i]);
    … …  
    196196
    197197        for (i = 0; i < _staticPictCount[index]; i++) {
    198198                if (_statics[index].piecesFromExt[i] == 1)
    199                         free(_statics[index].pieces[i]);
     199                        delete[] _statics[index].pieces[i];
    200200
    201201                spr = _staticPictToSprite[index * 7 + i];
    202202                _spriteRefs[spr]--;
    … …  
    207207                }
    208208        }
    209209
    210         free(_statics[index].layers);
    211         free(_statics[index].pieces);
    212         free(_statics[index].piecesFromExt);
     210        delete[] _statics[index].layers;
     211        delete[] _statics[index].pieces;
     212        delete[] _statics[index].piecesFromExt;
    213213        if (_staticFromExt[index] == 1)
    214                 free(_statics[index].dataPtr);
     214                delete[] _statics[index].dataPtr;
    215215
    216216        _staticFromExt[index] = 0;
    217217        _staticPictCount[index] = -1;
    … …  
    433433        ptr->layersCount = READ_LE_UINT16(dataPtr);
    434434        dataPtr += 2;
    435435
    436         ptr->layers =
    437             (AnimLayer **) malloc(sizeof(AnimLayer *) *
    438             ptr->layersCount);
    439         ptr->pieces =
    440             (PieceDesc **) malloc(sizeof(PieceDesc *) *
    441             picsCount);
    442         ptr->piecesFromExt = (int8 *) malloc(picsCount);
     436        ptr->layers = new AnimLayer*[ptr->layersCount];
     437        ptr->pieces = new PieceDesc*[picsCount];
     438        ptr->piecesFromExt = new int8[picsCount];
    443439
    444440        for (i = 0; i < ptr->layersCount; i++) {
    445441                offset = (int16)READ_LE_UINT16(&((int16 *)dataPtr)[i]);
    … …  
    718714
    719715        for (i = 0; i < _animPictCount[animation]; i++) {
    720716                if (_animations[animation].piecesFromExt[i] == 1)
    721                         free(_animations[animation].pieces[i]);
     717                        delete[] _animations[animation].pieces[i];
    722718
    723719                spr = _animPictToSprite[animation * 7 + i];
    724720                _spriteRefs[spr]--;
    … …  
    730726                }
    731727        }
    732728
    733         free(_animations[animation].layers);
    734         free(_animations[animation].pieces);
    735         free(_animations[animation].piecesFromExt);
     729        delete[] _animations[animation].layers;
     730        delete[] _animations[animation].pieces;
     731        delete[] _animations[animation].piecesFromExt;
    736732        if (_animFromExt[animation] == 1)
    737                 free(_animations[animation].dataPtr);
     733                delete[] _animations[animation].dataPtr;
    738734
    739735        _animFromExt[animation] = 0;
    740736        _animPictCount[animation] = 0;

  • scenery.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/scenery.h,v
retrieving revision 1.10
diff -u -r1.10 scenery.h
     
    2727class Scenery {
    2828public:
    2929#pragma START_PACK_STRUCTS
    30         typedef struct PieceDesc {
     30        struct PieceDesc {
    3131                int16 left;             //NOTE:
    3232                int16 right;            //These are stored in Little Endian format
    3333                int16 top;              //And should be converted by client code when accessed
    3434                int16 bottom;           //i.e. use FROM_LE_16()
    35         } GCC_PACK PieceDesc;
     35        } GCC_PACK;
    3636
    37         typedef struct StaticPlane {
     37        struct StaticPlane {
    3838                int8 pictIndex;
    3939                int8 pieceIndex;
    4040                int8 drawOrder;
    4141                int16 destX;
    4242                int16 destY;
    4343                int8 transp;
    44         } GCC_PACK StaticPlane;
     44        } GCC_PACK;
    4545
    46         typedef struct StaticLayer {
     46        struct StaticLayer {
    4747                int16 backResId;
    4848                int16 planeCount;
    4949                StaticPlane planes[1];
    50         } GCC_PACK StaticLayer;
     50        } GCC_PACK;
    5151
    5252        // Animations
    5353
    54         typedef struct AnimFramePiece {
     54        struct AnimFramePiece {
    5555                byte pictIndex;
    5656                byte pieceIndex;
    5757                int8 destX;
    5858                int8 destY;
    5959                int8 notFinal;
    60         } GCC_PACK AnimFramePiece;
     60        } GCC_PACK;
    6161
    62         typedef struct AnimLayer {
     62        struct AnimLayer {
    6363                int16 unknown0;
    6464                int16 posX;
    6565                int16 posY;
    … …  
    6868                int8 transp;
    6969                int16 framesCount;
    7070                AnimFramePiece frames[1];
    71         } GCC_PACK AnimLayer;
     71        } GCC_PACK;
    7272#pragma END_PACK_STRUCTS
    7373
    74         typedef struct Static {
     74        struct Static {
    7575                int16 layersCount;
    7676                StaticLayer **layers;
    7777                PieceDesc **pieces;
    … …  
    7979                char *dataPtr;
    8080                Static() : layersCount(0), layers(0), pieces(0),
    8181                                   piecesFromExt(0), dataPtr(0) {}
    82         } Static;
     82        };
    8383
    8484        struct Animation {
    8585                int16 layersCount;

  • sound.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/sound.cpp,v
retrieving revision 1.16
diff -u -r1.16 sound.cpp
     
    118118
    119119Snd::SoundDesc *Snd::loadSoundData(const char *path) {
    120120        Snd::SoundDesc *sndDesc;
    121         int32 size;
    122121
    123         size = _vm->_dataio->getDataSize(path);
    124         sndDesc = (Snd::SoundDesc *)malloc(size);
    125         sndDesc->size = size;
     122        sndDesc = new Snd::SoundDesc;
     123        sndDesc->size = _vm->_dataio->getDataSize(path);
    126124        sndDesc->data = _vm->_dataio->getData(path);
    127125
    128126        return sndDesc;
    … …  
    136134                        _loopingSounds[i] = NULL;
    137135        }
    138136
    139         free(sndDesc->data);
    140         free(sndDesc);
     137        delete[] sndDesc->data;
     138        delete sndDesc;
    141139}
    142140
    143141}                               // End of namespace Gob

  • sound.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/sound.h,v
retrieving revision 1.12
diff -u -r1.12 sound.h
     
    2828
    2929class Snd {
    3030public:
    31         typedef struct SoundDesc {
     31        struct SoundDesc {
    3232                Audio::SoundHandle handle;
    3333                char *data;
    3434                int32 size;
    … …  
    3939                int16 flag;
    4040                SoundDesc() : data(0), size(0), repCount(0), timerTicks(0),
    4141                                          inClocks(0), frequency(0), flag(0) {}
    42         } SoundDesc;
     42        };
    4343
    4444        typedef void (*CleanupFuncPtr) (int16);
    4545

  • util.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/util.cpp,v
retrieving revision 1.21
diff -u -r1.21 util.cpp
     
    271271}
    272272
    273273Video::FontDesc *Util::loadFont(const char *path) {
    274         Video::FontDesc *fontDesc = (Video::FontDesc *) malloc(sizeof(Video::FontDesc));
     274        Video::FontDesc *fontDesc = new Video::FontDesc;
    275275        char *data;
    276276
    277277        if (fontDesc == 0)
    … …  
    279279
    280280        data = _vm->_dataio->getData(path);
    281281        if (data == 0) {
    282                 free(fontDesc);
     282                delete fontDesc;
    283283                return 0;
    284284        }
    285285
    … …  
    303303}
    304304
    305305void Util::freeFont(Video::FontDesc * fontDesc) {
    306         free(fontDesc->dataPtr - 4);
    307         free(fontDesc);
     306        delete[] (fontDesc->dataPtr - 4);
     307        delete fontDesc;
    308308}
    309309
    310310void Util::clearPalette(void) {
    … …  
    390390void Util::listInsertFront(List * list, void *data) {
    391391        ListNode *node;
    392392
    393         node = (ListNode *) malloc(sizeof(ListNode));
     393        node = new ListNode;
    394394        if (list->pHead != 0) {
    395395                node->pData = data;
    396396                node->pNext = list->pHead;
    … …  
    415415                        warning("listInsertBack: Broken list!");
    416416                }
    417417
    418                 node =
    419                     (ListNode *) malloc(sizeof(ListNode));
     418                node = new ListNode;
    420419                node->pData = data;
    421420                node->pPrev = list->pTail;
    422421                node->pNext = 0;
    … …  
    429428
    430429void Util::listDropFront(List * list) {
    431430        if (list->pHead->pNext == 0) {
    432                 free((list->pHead));
     431                delete list->pHead;
    433432                list->pHead = 0;
    434433                list->pTail = 0;
    435434        } else {
    436435                list->pHead = list->pHead->pNext;
    437                 free((list->pHead->pPrev));
     436                delete list->pHead->pPrev;
    438437                list->pHead->pPrev = 0;
    439438        }
    440439}
    … …  
    444443                listDropFront(list);
    445444        }
    446445
    447         free(list);
     446        delete list;
    448447}
    449448
    450449const char Util::trStr1[] =

  • util.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/util.h,v
retrieving revision 1.8
diff -u -r1.8 util.h
     
    3131class Util {
    3232public:
    3333        struct ListNode;
    34         typedef struct ListNode {
     34        struct ListNode {
    3535                void *pData;
    3636                struct ListNode *pNext;
    3737                struct ListNode *pPrev;
    3838                ListNode() : pData(0), pNext(0), pPrev(0) {}
    39         } ListNode;
     39        };
    4040
    41         typedef struct List {
     41        struct List {
    4242                ListNode *pHead;
    4343                ListNode *pTail;
    4444                List() : pHead(0), pTail(0) {}
    45         } List;
     45        };
    4646
    4747        void initInput(void);
    4848        void processInput(void);

  • video.cpp 

    RCS file: /cvsroot/scummvm/scummvm/gob/video.cpp,v
retrieving revision 1.19
diff -u -r1.19 video.cpp
     
    8585
    8686Video::SurfaceDesc *Video::initSurfDesc(int16 vidMode, int16 width, int16 height, int16 flags) {
    8787        int8 flagsAnd2;
    88         byte *vidMem;
     88        byte *vidMem = 0;
    8989        int32 sprSize;
    9090        int16 someFlags = 1;
    9191        SurfaceDesc *descPtr;
    … …  
    108108                flagsAnd2 = 0;
    109109
    110110        if (flags & PRIMARY_SURFACE) {
    111                 vidMem = 0;
    112111                _vm->_global->_primaryWidth = width;
    113112                _vm->_global->_mouseMaxCol = width;
    114113                _vm->_global->_primaryHeight = height;
    115114                _vm->_global->_mouseMaxRow = height;
    116115                sprSize = 0;
    117 
    118116        } else {
    119                 vidMem = 0;
    120117                sprSize = Video::getRectSize(width, height, flagsAnd2, vidMode);
    121118                if (flagsAnd2)
    122119                        someFlags += 0x80;
    123120        }
    124121        if (flags & PRIMARY_SURFACE) {
    125122                descPtr = _vm->_global->_pPrimarySurfDesc;
    126                 vidMem = (byte *)malloc(320 * 200);
     123                delete[] descPtr->vidPtr;
     124                assert(descPtr);
     125                vidMem = new byte[320 * 200];
    127126        } else {
    128                 if (flags & DISABLE_SPR_ALLOC)
    129                         descPtr = (SurfaceDesc *)malloc(sizeof(SurfaceDesc));
    130                 else
    131                         descPtr = (SurfaceDesc *)malloc(sizeof(SurfaceDesc) + sprSize);
     127                if (flags & DISABLE_SPR_ALLOC) {
     128                        descPtr = new SurfaceDesc;
     129                        // this case causes vidPtr to be set to invalid memory
     130                        assert(false);
     131                } else {
     132                        descPtr = new SurfaceDesc;
     133                        descPtr->vidPtr = new byte[sprSize];
     134                        vidMem = descPtr->vidPtr;
     135                }
    132136        }
    133137        if (descPtr == 0)
    134138                return 0;
    … …  
    137141        descPtr->height = height;
    138142        descPtr->flag = someFlags;
    139143        descPtr->vidMode = vidMode;
    140         if (vidMem == 0)
    141                 vidMem = ((byte *)descPtr) + sizeof(SurfaceDesc);
    142144        descPtr->vidPtr = vidMem;
    143145
    144146        descPtr->reserved1 = 0;
    … …  
    147149}
    148150
    149151void Video::freeSurfDesc(SurfaceDesc * surfDesc) {
    150         _vm->_global->_sprAllocated--;
    151         if (surfDesc != _vm->_global->_pPrimarySurfDesc)
    152                 free(surfDesc);
    153         else
    154                 free(surfDesc->vidPtr);
     152        delete[] surfDesc->vidPtr;
     153        if (surfDesc != _vm->_global->_pPrimarySurfDesc) {
     154                _vm->_global->_sprAllocated--;
     155                delete surfDesc;
     156        }
    155157}
    156158
    157159int16 Video::clampValue(int16 val, int16 max) {
    … …  
    302304                return;
    303305
    304306        if ((dest->vidMode & 0x7f) != 0x13)
    305                 error("Video::drawPackedSprite: Vide mode 0x%x is not fully supported!",
     307                error("Video::drawPackedSprite: Video mode 0x%x is not fully supported!",
    306308                    dest->vidMode & 0x7f);
    307309
    308310        _videoDriver->drawPackedSprite(sprBuf, width, height, x, y, transp, dest);
    … …  
    378380
    379381void Video::initPrimary(int16 mode) {
    380382        int16 old;
    381         if (_vm->_global->_curPrimaryDesc) {
    382                 Video::freeSurfDesc(_vm->_global->_curPrimaryDesc);
    383                 Video::freeSurfDesc(_vm->_global->_allocatedPrimary);
    384 
    385                 _vm->_global->_curPrimaryDesc = 0;
    386                 _vm->_global->_allocatedPrimary = 0;
    387         }
    388383        if (mode != 0x13 && mode != 3 && mode != -1)
    389384                error("Video::initPrimary: Video mode 0x%x is not supported!",
    390385                    mode);
    … …  
    450445                    srcHeight - 1, x, y, transp);
    451446                return 1;
    452447        } else {
    453                 memBuffer = (byte *)malloc(4114);
     448                memBuffer = new byte[4114];
    454449                if (memBuffer == 0)
    455450                        return 0;
    456451
    … …  
    520515                                                destPtr = linePtr;
    521516                                                curHeight++;
    522517                                                if (curHeight >= srcHeight) {
    523                                                         free(memBuffer);
     518                                                        delete[] memBuffer;
    524519                                                        return 1;
    525520                                                }
    526521                                        }
    527522                                        sourceLeft--;
    528523                                        if (sourceLeft == 0) {
    529                                                 free(memBuffer);
     524                                                delete[] memBuffer;
    530525                                                return 1;
    531526                                        }
    532527                                        memBuffer[bufPos] = temp;
    … …  
    536531                        }
    537532                }
    538533        }
    539         free(memBuffer);
     534        delete[] memBuffer;
    540535        return 1;
    541536}
    542537

  • video.h 

    RCS file: /cvsroot/scummvm/scummvm/gob/video.h,v
retrieving revision 1.12
diff -u -r1.12 video.h
     
    4040
    4141class Video {
    4242public:
    43         typedef struct SurfaceDesc_t {
     43        struct SurfaceDesc {
    4444                int16 width;
    4545                int16 height;
    4646                int8 reserved1;
    … …  
    4848                int16 vidMode;
    4949                byte *vidPtr;
    5050                int16 reserved2;
    51                 SurfaceDesc_t() : width(0), height(0), reserved1(0), flag(0),
     51                SurfaceDesc() : width(0), height(0), reserved1(0), flag(0),
    5252                                                  vidMode(0), vidPtr(0), reserved2(0) {}
    53         } SurfaceDesc;
     53        };
    5454
    55         typedef struct FontDesc_t {
     55        struct FontDesc {
    5656                char *dataPtr;
    5757                int8 itemWidth;
    5858                int8 itemHeight;
    … …  
    6161                int8 itemSize;
    6262                int8 bitWidth;
    6363                void *extraData;
    64                 FontDesc_t() : dataPtr(0), itemWidth(0), itemHeight(0), startItem(0),
     64                FontDesc() : dataPtr(0), itemWidth(0), itemHeight(0), startItem(0),
    6565                                       endItem(0), itemSize(0), bitWidth(0) {}
    66         } FontDesc;
     66        };
    6767
    6868#define GDR_VERSION     4
    6969
    … …  
    7373
    7474#pragma START_PACK_STRUCTS
    7575
    76         typedef struct Color {
     76        struct Color {
    7777                byte red;
    7878                byte green;
    7979                byte blue;
    80         } GCC_PACK Color;
     80        } GCC_PACK;
    8181
    8282#pragma END_PACK_STRUCTS
    8383
    84         typedef struct PalDesc {
     84        struct PalDesc {
    8585                Color *vgaPal;
    8686                int16 *unused1;
    8787                int16 *unused2;
    8888                PalDesc() : vgaPal(0), unused1(0), unused2(0) {}
    89         } PalDesc;
     89        };
    9090
    9191        Video(class GobEngine *vm);
    9292        int32 getRectSize(int16 width, int16 height, int16 flag, int16 mode);