Ticket #8274: scummvm.patch

File scummvm.patch, 19.1 KB (added by SF/johneck, 16 years ago)

Patch

  • common/file.cpp

    diff -uri scummvm-original/common/file.cpp scummvm/common/file.cpp
    old new  
    2828        char buf[512];
    2929        char *ptr;
    3030
    31         assert(directory);
     31        assert(directory != NULL);
    3232        strcpy(buf, directory);
    3333
    3434#ifdef WIN32
  • common/util.cpp

    diff -uri scummvm-original/common/util.cpp scummvm/common/util.cpp
    old new  
    178178}
    179179
    180180void StackLock::lock() {
    181         assert(_syst);
     181        assert(_syst != NULL);
    182182        _syst->lock_mutex(_mutex);
    183183}
    184184
    185185void StackLock::unlock() {
    186         assert(_syst);
     186        assert(_syst != NULL);
    187187        _syst->unlock_mutex(_mutex);
    188188}
    189189
  • gui/newgui.cpp

    diff -uri scummvm-original/gui/newgui.cpp scummvm/gui/newgui.cpp
    old new  
    451451void NewGui::blitFromBuffer(int x, int y, int w, int h, const byte *buf, int pitch) {
    452452        NewGuiColor *ptr = getBasePtr(x, y);
    453453
    454         assert(buf);
     454        assert(buf != NULL);
    455455        while (h--) {
    456456                memcpy(ptr, buf, w*2);
    457457                ptr += _screenPitch;
     
    465465void NewGui::blitToBuffer(int x, int y, int w, int h, byte *buf, int pitch) {
    466466        NewGuiColor *ptr = getBasePtr(x, y);
    467467
    468         assert(buf);
     468        assert(buf != NULL);
    469469        while (h--) {
    470470                memcpy(buf, ptr, w*2);
    471471                ptr += _screenPitch;
  • scumm/actor.cpp

    diff -uri scummvm-original/scumm/actor.cpp scummvm/scumm/actor.cpp
    old new  
    10351035
    10361036                if (_vm->_features & GF_NEW_COSTUMES) {
    10371037                        byte *akos = _vm->getResourceAddress(rtCostume, costume);
    1038                         assert(akos);
     1038                        assert(akos != NULL);
    10391039                        if (_vm->akos_increaseAnims(akos, this)) {
    10401040                                needRedraw = true;
    10411041                        }
     
    10671067                const byte *aksq, *akfo;
    10681068                uint size;
    10691069                byte *akos = _vm->getResourceAddress(rtCostume, costume);
    1070                 assert(akos);
     1070                assert(akos != NULL);
    10711071
    10721072                aksq = _vm->findResourceData(MKID('AKSQ'), akos);
    10731073                akfo = _vm->findResourceData(MKID('AKFO'), akos);
  • scumm/akos.cpp

    diff -uri scummvm-original/scumm/akos.cpp scummvm/scumm/akos.cpp
    old new  
    117117        const AkosHeader *akhd;
    118118
    119119        akos = getResourceAddress(rtCostume, a->costume);
    120         assert(akos);
     120        assert(akos != NULL);
    121121
    122122        akhd = (const AkosHeader *)findResourceData(MKID('AKHD'), akos);
    123123        return (akhd->flags & 2) != 0;
     
    146146        anim = akos_frameToAnim(a, frame);
    147147
    148148        akos = getResourceAddress(rtCostume, a->costume);
    149         assert(akos);
     149        assert(akos != NULL);
    150150
    151151        akhd = (const AkosHeader *)findResourceData(MKID('AKHD'), akos);
    152152
     
    154154                return;
    155155
    156156        r = findResourceData(MKID('AKCH'), akos);
    157         assert(r);
     157        assert(r != NULL);
    158158
    159159        offs = READ_LE_UINT16(r + anim * sizeof(uint16));
    160160        if (offs == 0)
     
    231231
    232232void AkosRenderer::setCostume(int costume) {
    233233        akos = _vm->getResourceAddress(rtCostume, costume);
    234         assert(akos);
     234        assert(akos != NULL);
    235235
    236236        akhd = (const AkosHeader *) _vm->findResourceData(MKID('AKHD'), akos);
    237237        akof = (const AkosOffset *) _vm->findResourceData(MKID('AKOF'), akos);
  • scumm/bomp.cpp

    diff -uri scummvm-original/scumm/bomp.cpp scummvm/scumm/bomp.cpp
    old new  
    242242
    243243        // Setup vertical scaling
    244244        if (bd.scale_y != 255) {
    245                 assert(scalingYPtr);
     245                assert(scalingYPtr != NULL);
    246246
    247247                skip_y_new = *scalingYPtr++;
    248248                skip_y_bits = 0x80;
     
    254254
    255255        // Setup horizontal scaling
    256256        if (bd.scale_x != 255) {
    257                 assert(bd.scalingXPtr);
     257                assert(bd.scalingXPtr != NULL);
    258258                if (clip_right > bd.scaleRight) {
    259259                        clip_right = bd.scaleRight;
    260260                }
  • scumm/boxes.cpp

    diff -uri scummvm-original/scumm/boxes.cpp scummvm/scumm/boxes.cpp
    old new  
    109109                _extraBoxFlags[box] = val;
    110110        } else {
    111111                Box *ptr = getBoxBaseAddr(box);
    112                 assert(ptr);
     112                assert(ptr != NULL);
    113113                if (_version == 8)
    114114                        ptr->v8.flags = TO_LE_32(val);
    115115                else if (_version <= 2)
     
    133133
    134134void Scumm::setBoxScale(int box, int scale) {
    135135        Box *ptr = getBoxBaseAddr(box);
    136         assert(ptr);
     136        assert(ptr != NULL);
    137137        if (_version == 8)
    138138                ptr->v8.scale = TO_LE_32(scale);
    139139        else if (_version <= 2)
     
    144144
    145145void Scumm::setBoxScaleSlot(int box, int slot) {
    146146        Box *ptr = getBoxBaseAddr(box);
    147         assert(ptr);
     147        assert(ptr != NULL);
    148148        ptr->v8.scaleSlot = TO_LE_32(slot);
    149149}
    150150
     
    373373
    374374void Scumm::getBoxCoordinates(int boxnum, BoxCoords *box) {
    375375        Box *bp = getBoxBaseAddr(boxnum);
    376         assert(bp);
     376        assert(bp != NULL);
    377377
    378378        if (_version == 8) {
    379379                box->ul.x = (short)FROM_LE_32(bp->v8.ulx);
     
    601601
    602602byte *Scumm::getBoxMatrixBaseAddr() {
    603603        byte *ptr = getResourceAddress(rtMatrix, 1);
    604         assert(ptr);
     604        assert(ptr != NULL);
    605605        if (*ptr == 0xFF)
    606606                ptr++;
    607607        return ptr;
  • scumm/charset.cpp

    diff -uri scummvm-original/scumm/charset.cpp scummvm/scumm/charset.cpp
    old new  
    12421242        assert(id < 5);
    12431243        _curId = id;
    12441244        _current = _fr[id];
    1245         assert(_current);
     1245        assert(_current != NULL);
    12461246}
    12471247
    12481248int CharsetRendererNut::getCharWidth(byte chr) {
    1249         assert(_current);
     1249        assert(_current != NULL);
    12501250        return _current->getCharWidth(chr);
    12511251}
    12521252
    12531253int CharsetRendererNut::getFontHeight() {
    12541254        // FIXME / TODO: how to implement this properly???
    1255         assert(_current);
     1255        assert(_current != NULL);
    12561256        return _current->getCharHeight('|');
    12571257}
    12581258
    12591259void CharsetRendererNut::printChar(int chr) {
    12601260        int shadow_left, shadow_right, shadow_top, shadow_bottom;
    12611261
    1262         assert(_current);
     1262        assert(_current != NULL);
    12631263        if (chr == '@')
    12641264                return;
    12651265
  • scumm/gfx.cpp

    diff -uri scummvm-original/scumm/gfx.cpp scummvm/scumm/gfx.cpp
    old new  
    894894 */
    895895void Gdi::drawBitmap(const byte *ptr, VirtScreen *vs, int x, int y, const int width, const int height,
    896896                     int stripnr, int numstrip, byte flag, StripTable *table) {
    897         assert(ptr);
     897        assert(ptr != NULL);
    898898        assert(height > 0);
    899899        byte *backbuff_ptr, *bgbak_ptr;
    900900        const byte *smap_ptr;
     
    921921        else
    922922                smap_ptr = findResource(MKID('SMAP'), ptr);
    923923
    924         assert(smap_ptr);
     924        assert(smap_ptr != NULL);
    925925
    926926        zplane_list[0] = smap_ptr;
    927927
     
    33093309        const byte *cptr;
    33103310
    33113311        cptr = getResourceAddress(rtRoom, _roomResource);
    3312         assert(cptr);
     3312        assert(cptr != NULL);
    33133313        if (_CLUT_offs) {
    33143314                cptr += _CLUT_offs;
    33153315        } else {
    33163316                cptr = findPalInPals(cptr + _PALS_offs, _curPalIndex);
    33173317        }
    3318         assert(cptr);
     3318        assert(cptr != NULL);
    33193319        return cptr;
    33203320}
    33213321
  • scumm/object.cpp

    diff -uri scummvm-original/scumm/object.cpp scummvm/scumm/object.cpp
    old new  
    244244                        return;
    245245                }
    246246                imhd = (const ImageHeader *)findResourceData(MKID('IMHD'), ptr);
    247                 assert(imhd);
     247                assert(imhd != NULL);
    248248                if (_version == 8) {
    249249                        x = od.x_pos + (int32)READ_LE_UINT32(&imhd->v8.hotspot[state].x);
    250250                        y = od.y_pos + (int32)READ_LE_UINT32(&imhd->v8.hotspot[state].y);
     
    501501                searchptr = rootptr = getResourceAddress(rtRoomScripts, _roomResource);
    502502        else
    503503                searchptr = rootptr = room;
    504         assert(searchptr);
     504        assert(searchptr != NULL);
    505505
    506506        // Load in new room objects
    507507        ResourceIterator        obcds(searchptr, false);
     
    666666        const CodeHeader *cdhd = NULL;
    667667        const ImageHeader *imhd = NULL;
    668668
    669         assert(room);
     669        assert(room != NULL);
    670670
    671671        if (_features & GF_SMALL_HEADER) {
    672672
     
    941941                                        ptr = getResourceAddress(rtRoomScripts, _roomResource);
    942942                                else
    943943                                        ptr = getResourceAddress(rtRoom, _roomResource);
    944                                 assert(ptr);
     944                                assert(ptr != NULL);
    945945                                return ptr + _objs[i].OBCDoffset;
    946946                        }
    947947                }
     
    964964}
    965965
    966966const byte *Scumm::getObjectImage(const byte *ptr, int state) {
    967         assert(ptr);
     967        assert(ptr != NULL);
    968968        if (_features & GF_OLD_BUNDLE)
    969969                ptr += 0;
    970970        else if (_features & GF_SMALL_HEADER) {
     
    10231023        slot = getInventorySlot();
    10241024        _inventory[slot] = obj;
    10251025        dst = createResource(rtInventory, slot, size);
    1026         assert(dst);
     1026        assert(dst != NULL);
    10271027        memcpy(dst, ptr, size);
    10281028
    10291029        CHECK_HEAP
     
    10461046                        error("findObjectInRoom foCheckAlreadyLoaded NYI for GF_OLD_BUNDLE (id = %d, room = %d)", id, room);
    10471047                }
    10481048                fo->obcd = obcdptr = getOBCDFromObject(id);
    1049                 assert(obcdptr);
     1049                assert(obcdptr != NULL);
    10501050                fo->obim = obimptr = obcdptr + RES_SIZE(obcdptr);
    10511051                fo->cdhd = (const CodeHeader *)findResourceData(MKID('CDHD'), obcdptr);
    10521052                fo->imhd = (const ImageHeader *)findResourceData(MKID('IMHD'), obimptr);
     
    11071107                        searchptr = getResourceAddress(rtRoomScripts, room);
    11081108                else
    11091109                        searchptr = roomptr;
    1110                 assert(searchptr);
     1110                assert(searchptr != NULL);
    11111111                ResourceIterator        obcds(searchptr, (_features & GF_SMALL_HEADER) != 0);
    11121112                for (i = 0;;) {
    11131113                        obcdptr = obcds.findNext(MKID('OBCD'));
     
    13591359        }
    13601360
    13611361        dataptr = getObjectImage(foir.obim, imgindex);
    1362         assert(dataptr);
     1362        assert(dataptr != NULL);
    13631363        if (_version == 8) {
    13641364                bomp = dataptr;
    13651365        } else {
     
    14581458
    14591459        const byte *img = getObjectImage(ptr, eo->image);
    14601460        if (_version == 8) {
    1461                 assert(img);
     1461                assert(img != NULL);
    14621462                bomp = img + 8;
    14631463        } else {
    14641464                if (!img)
    14651465                        img = getObjectImage(ptr, 1);   // Backward compatibility with samnmax blast objects
    1466                 assert(img);
     1466                assert(img != NULL);
    14671467                bomp = findResourceData(MKID('BOMP'), img);
    14681468        }
    14691469
     
    16361636        // Allocate slot & memory for floating object
    16371637        slot = findFlObjectSlot();
    16381638        flob = createResource(rtFlObject, slot, flob_size);
    1639         assert(flob);
     1639        assert(flob != NULL);
    16401640
    16411641        // Copy object code + object image to floating object
    16421642        ((uint32 *)flob)[0] = MKID('FLOB');
  • scumm/resource.cpp

    diff -uri scummvm-original/scumm/resource.cpp scummvm/scumm/resource.cpp
    old new  
    20522052
    20532053ResourceIterator::ResourceIterator(const byte *searchin, bool smallHeader)
    20542054        : _ptr(searchin), _smallHeader(smallHeader) {
    2055         assert(searchin);
     2055        assert(searchin != NULL);
    20562056        if (_smallHeader) {
    20572057                _size = READ_LE_UINT32(searchin);
    20582058                _pos = 6;
     
    21042104const byte *findResource(uint32 tag, const byte *searchin) {
    21052105        uint32 curpos, totalsize, size;
    21062106
    2107         assert(searchin);
     2107        assert(searchin != NULL);
    21082108
    21092109        searchin += 4;
    21102110        totalsize = READ_BE_UINT32(searchin);
     
    21372137        if (smallTag == 0)
    21382138                return NULL;
    21392139
    2140         assert(searchin);
     2140        assert(searchin != NULL);
    21412141
    21422142        totalsize = READ_LE_UINT32(searchin);
    21432143        searchin += 6;
  • scumm/script.cpp

    diff -uri scummvm-original/scumm/script.cpp scummvm/scumm/script.cpp
    old new  
    139139                return 0;
    140140
    141141        objptr = getOBCDFromObject(obj);
    142         assert(objptr);
     142        assert(objptr != NULL);
    143143
    144144        if (_version <= 2)
    145145                verbptr = objptr + 15;
     
    150150        else
    151151                verbptr = findResource(MKID('VERB'), objptr);
    152152
    153         assert(verbptr);
     153        assert(verbptr != NULL);
    154154
    155155        verboffs = verbptr - objptr;
    156156
  • scumm/script_v2.cpp

    diff -uri scummvm-original/scumm/script_v2.cpp scummvm/scumm/script_v2.cpp
    old new  
    971971                if ((_gameId == GID_MANIAC && _version == 1) && (VAR(VAR_SENTENCE_PREPOSITION) == 0)) {
    972972                        if (_verbs[slot].prep == 0xFF) {
    973973                                byte *ptr = getOBCDFromObject(VAR(VAR_SENTENCE_OBJECT1));
    974                                 assert(ptr);
     974                                assert(ptr != NULL);
    975975                                VAR(VAR_SENTENCE_PREPOSITION) = (*(ptr+12) >> 5);
    976976                        } else
    977977                                VAR(VAR_SENTENCE_PREPOSITION) = _verbs[slot].prep;
  • scumm/script_v5.cpp

    diff -uri scummvm-original/scumm/script_v5.cpp scummvm/scumm/script_v5.cpp
    old new  
    821821        getResultPos();
    822822        string = getVarOrDirectByte(0x80);
    823823        ptr = getResourceAddress(rtString, string);
    824         assert(ptr);
     824        assert(ptr != NULL);
    825825
    826826        width = _charset->getStringWidth(0, ptr);
    827827       
     
    19521952                byte *searchin = objptr;
    19531953                uint32 curpos, totalsize;
    19541954       
    1955                 assert(searchin);
     1955                assert(searchin != NULL);
    19561956       
    19571957                searchin += 4;
    19581958                totalsize = READ_BE_UINT32(searchin);
  • scumm/script_v6.cpp

    diff -uri scummvm-original/scumm/script_v6.cpp scummvm/scumm/script_v6.cpp
    old new  
    23862386//                                      _imuseDigital->stopAll();
    23872387//                              }
    23882388                                uint32 speed;
    2389                                 assert(getStringAddressVar(VAR_VIDEONAME));
     2389                                assert(getStringAddressVar(VAR_VIDEONAME) != NULL);
    23902390                                if (strcmp((char *)getStringAddressVar(VAR_VIDEONAME), "sq3.san") == 0)
    23912391                                        speed = 71000;
    23922392                                else {
  • scumm/script_v8.cpp

    diff -uri scummvm-original/scumm/script_v8.cpp scummvm/scumm/script_v8.cpp
    old new  
    11111111
    11121112        assert(0 <= _curVerbSlot && _curVerbSlot < _maxVerbs);
    11131113        vs = &_verbs[_curVerbSlot];
    1114         assert(vs);
     1114        assert(vs != NULL);
    11151115
    11161116        switch (subOp) {
    11171117        case 0x96:              // SO_VERB_INIT Choose verb number for editing
  • scumm/smush/imuse_channel.cpp

    diff -uri scummvm-original/scumm/smush/imuse_channel.cpp scummvm/scumm/smush/imuse_channel.cpp
    old new  
    189189        byte *keep, *decoded;
    190190        uint32 value;
    191191        keep = decoded = new byte[new_size * 2];
    192         assert(keep);
     192        assert(keep != NULL);
    193193        unsigned char * source = _sbuffer;
    194194                while (loop_size--) {
    195195                byte v1 =  *source++;
  • scumm/smush/smush_font.cpp

    diff -uri scummvm-original/scumm/smush/smush_font.cpp scummvm/scumm/smush/smush_font.cpp
    old new  
    3333}
    3434
    3535int SmushFont::getStringWidth(const char *str) {
    36         assert(str);
     36        assert(str != NULL);
    3737        if (!_loaded) {
    3838                warning("SmushFont::getStringWidth() Font is not loaded");
    3939                return 0;
     
    4747}
    4848
    4949int SmushFont::getStringHeight(const char *str) {
    50         assert(str);
     50        assert(str != NULL);
    5151        if (!_loaded) {
    5252                warning("SmushFont::getStringHeight() Font is not loaded");
    5353                return 0;
  • scumm/smush/smush_player.cpp

    diff -uri scummvm-original/scumm/smush/smush_player.cpp scummvm/scumm/smush/smush_player.cpp
    old new  
    110110                        data_end -= 2;
    111111                        assert(data_end > data_start);
    112112                        char *value = new char[data_end - data_start + 1];
    113                         assert(value);
     113                        assert(value != NULL);
    114114                        memcpy(value, data_start, data_end - data_start);
    115115                        value[data_end - data_start] = 0;
    116116                        char *line_start = value;
     
    163163        }
    164164        int32 length = theFile.size();
    165165        char *filebuffer = new char [length + 1];
    166         assert(filebuffer);
     166        assert(filebuffer != NULL);
    167167        theFile.read(filebuffer, length);
    168168        filebuffer[length] = 0;
    169169
     
    187187                length -= ETRS_HEADER_LENGTH;
    188188        }
    189189        StringResource *sr = new StringResource;
    190         assert(sr);
     190        assert(sr != NULL);
    191191        sr->init(filebuffer, length);
    192192        delete []filebuffer;
    193193        return sr;
     
    707707
    708708        int32 chunk_size = b.getSize() - 14;
    709709        byte *chunk_buffer = (byte *)malloc(chunk_size);
    710         assert(chunk_buffer);
     710        assert(chunk_buffer != NULL);
    711711        b.read(chunk_buffer, chunk_size);
    712712
    713713        switch (codec) {
  • scumm/sound.cpp

    diff -uri scummvm-original/scumm/sound.cpp scummvm/scumm/sound.cpp
    old new  
    179179        ptr = _scumm->getResourceAddress(rtSound, soundID);
    180180        if (ptr) {
    181181                if (READ_UINT32(ptr) == MKID('iMUS')){
    182                         assert(_scumm->_imuseDigital);
     182                        assert(_scumm->_imuseDigital != NULL);
    183183                        _scumm->_imuseDigital->startSound(soundID);
    184184                        return;
    185185                }
    186186                else if (READ_UINT32(ptr) == MKID('Crea')) {
    187                         assert(_scumm->_imuseDigital);
     187                        assert(_scumm->_imuseDigital != NULL);
    188188                        _scumm->_imuseDigital->startSound(soundID);
    189189                        return;
    190190                }
  • scumm/verbs.cpp

    diff -uri scummvm-original/scumm/verbs.cpp scummvm/scumm/verbs.cpp
    old new  
    226226
    227227                _string[1].color = v2_mouseover_boxes[i].color;
    228228                _messagePtr = getObjOrActorName(obj);
    229                 assert(_messagePtr);
     229                assert(_messagePtr != NULL);
    230230
    231231                // Prevent inventory entries from overflowing by truncating the text
    232232                // after 144/8 = 18 chars
     
    397397                _messagePtr = getResourceAddress(rtVerb, verb);
    398398                if (!_messagePtr)
    399399                        return;
    400                 assert(_messagePtr);
     400        /* this seems strange, the check above already does this for us, no? */
     401                assert(_messagePtr != NULL);
    401402
    402403                if ((_version == 8) && (_messagePtr[0] == '/')) {
    403404                        translateText(_messagePtr, _transText);
     
    453454        ydiff = y - vs->topline;
    454455
    455456        obim = getResourceAddress(rtVerb, verb);
    456         assert(obim);
     457        assert(obim != NULL);
    457458        if (_features & GF_OLD_BUNDLE) {
    458459                imgw = obim[0];
    459460                imgh = obim[1] >> 3;
     
    475476                }
    476477                imptr = getObjectImage(obim, 1);
    477478        }
    478         assert(imptr);
     479        assert(imptr != NULL);
    479480        if (_version == 1) {
    480481                gdi._C64ObjectMode = true;
    481482                gdi.decodeC64Gfx(imptr, gdi._C64ObjectMap, imgw * imgh * 3);
  • sound/mixer.cpp

    diff -uri scummvm-original/sound/mixer.cpp scummvm/sound/mixer.cpp
    old new  
    4949
    5050        Channel(SoundMixer *mixer, PlayingSoundHandle *handle)
    5151                : _mixer(mixer), _handle(handle), _converter(0), _input(0), _id(-1) {
    52                 assert(mixer);
     52                assert(mixer != NULL);
    5353        }
    5454        virtual ~Channel();
    5555        void destroy();
     
    247247}
    248248
    249249void SoundMixer::mixCallback(void *s, byte *samples, int len) {
    250         assert(s);
    251         assert(samples);
     250        assert(s != NULL);
     251        assert(samples != NULL);
    252252        // Len is the number of bytes in the buffer; we divide it by
    253253        // four to get the number of samples (stereo 16 bit).
    254254        ((SoundMixer *)s)->mix((int16 *)samples, len >> 2);
     
    383383   16 bits, for a total of 40 bytes.
    384384 */
    385385void Channel::mix(int16 *data, uint len) {
    386         assert(_input);
     386        assert(_input != NULL);
    387387        if (_input->eos()) {
    388388                // TODO: call drain method
    389389                destroy();
    390390        } else {
    391                 assert(_converter);
     391                assert(_converter != NULL);
    392392                _converter->flow(*_input, data, len, getVolume());
    393393        }
    394394}
     
    445445}
    446446
    447447void ChannelStream::mix(int16 *data, uint len) {
    448         assert(_input);
     448        assert(_input != NULL);
    449449        if (_input->eos()) {
    450450                // TODO: call drain method
    451451
     
    460460                return;
    461461        }
    462462
    463         assert(_converter);
     463        assert(_converter != NULL);
    464464        _converter->flow(*_input, data, len, getVolume());
    465465}
    466466