Ticket #8839: array3.patch

File array3.patch, 10.3 KB (added by SF/next_ghost, 12 years ago)

Improved ManagedArray

  • gui/massadd.cpp

     
    123123
    124124        // Perform a breadth-first scan of the filesystem.
    125125        while (!_scanStack.empty() && (g_system->getMillis() - t) < kMaxScanTime) {
    126                 FilesystemNode dir = _scanStack.pop();
     126                FilesystemNode dir = _scanStack.top();
     127                _scanStack.pop();
    127128
    128129                FSList files;
    129130                if (!dir.getChildren(files, FilesystemNode::kListAll)) {
  • engines/sword1/animation.cpp

     
    281281                                _textMan->releaseText(2);
    282282                                free(_textSpriteBuf);
    283283                                _textSpriteBuf = NULL;
    284                                 delete _movieTexts.remove_at(0);
     284                                delete _movieTexts[0];
     285                                _movieTexts.remove_at(0);
    285286                        }
    286287                }
    287288                processFrame();
     
    310311        }
    311312
    312313        while (!_movieTexts.empty()) {
    313                 delete _movieTexts.remove_at(_movieTexts.size() - 1);
     314                delete _movieTexts[_movieTexts.size() - 1];
     315                _movieTexts.remove_at(_movieTexts.size() - 1);
    314316        }
    315317
    316318        while (_snd->isSoundHandleActive(_bgSoundHandle))
  • engines/agi/picture.cpp

     
    267267
    268268        // Exit if stack is empty
    269269        while (!stack.empty()) {
    270                 Common::Point p = stack.pop();
     270                Common::Point p = stack.top();
    271271                unsigned int c;
    272272                int newspanUp, newspanDown;
    273273
     274                stack.pop();
     275
    274276                if (!isOkFillHere(p.x, p.y))
    275277                        continue;
    276278
  • engines/agi/predictive.cpp

     
    8383        words.push_back(word);
    8484        while ((word = strtok(NULL, " ")) != NULL)
    8585                words.push_back(word);
    86         words.insert_at(1, words.remove_at(wordnum + 1));
    8786
    88         Common::String tmp;
     87        Common::String tmp = words[wordnum + 1];
     88        words.remove_at(wordnum + 1);
     89        words.insert_at(1, tmp);
     90
     91        tmp = "";
    8992        for (uint8 i = 0; i < words.size(); i++)
    9093                        tmp += words[i] + " ";
    9194        tmp.deleteLastChar();
  • engines/lure/scripts.cpp

     
    971971                        break;
    972972
    973973                case S_OPCODE_ADD:
    974                         stack.push(stack.pop() + stack.pop());
     974                        tempVal = stack.top();
     975                        stack.pop();
     976                        tempVal += stack.top();
     977                        stack.pop();
     978                        stack.push(tempVal);
    975979                        break;
    976980
    977981                case S_OPCODE_SUBTRACT:
    978                         v1 = stack.pop();
    979                         v2 = stack.pop();
     982                        v1 = stack.top();
     983                        stack.pop();
     984                        v2 = stack.top();
     985                        stack.pop();
    980986                        stack.push(v2 - v1);
    981987                        break;
    982988
    983989                case S_OPCODE_MULTIPLY:
    984                         tempVal = stack.pop() * stack.pop();
     990                        tempVal = stack.top();
     991                        stack.pop();
     992                        tempVal *= stack.top();
     993                        stack.pop();
    985994                        stack.push(tempVal & 0xffff);
    986995                        param = (uint16) (tempVal >> 16);
    987996                        break;
    988997
    989998                case S_OPCODE_DIVIDE:
    990                         v1 = stack.pop();
    991                         v2 = stack.pop();
     999                        v1 = stack.top();
     1000                        stack.pop();
     1001                        v2 = stack.top();
     1002                        stack.pop();
    9921003                        stack.push(v2 / v1);
    9931004                        param = v2 % v1;      // remainder
    9941005                        break;
    9951006
    9961007                case S_OPCODE_EQUALS:
    997                         stack.push((stack.pop() == stack.pop()) ? 1 : 0);
     1008                        v1 = stack.top();
     1009                        stack.pop();
     1010                        v2 = stack.top();
     1011                        stack.pop();
     1012                        stack.push((v1 == v2) ? 1 : 0);
    9981013                        break;
    9991014
    10001015                case S_OPCODE_NOT_EQUALS:
    1001                         stack.push((stack.pop() != stack.pop()) ? 1 : 0);
     1016                        v1 = stack.top();
     1017                        stack.pop();
     1018                        v2 = stack.top();
     1019                        stack.pop();
     1020                        stack.push((v1 != v2) ? 1 : 0);
    10021021                        break;
    10031022
    10041023                case S_OPCODE_LT:
    1005                         v1 = stack.pop();
    1006                         v2 = stack.pop();
     1024                        v1 = stack.top();
     1025                        stack.pop();
     1026                        v2 = stack.top();
     1027                        stack.pop();
    10071028                        stack.push(v2 < v1 ? 1 : 0);
    10081029                        break;
    10091030
    10101031                case S_OPCODE_GT:
    1011                         v1 = stack.pop();
    1012                         v2 = stack.pop();
     1032                        v1 = stack.top();
     1033                        stack.pop();
     1034                        v2 = stack.top();
     1035                        stack.pop();
    10131036                        stack.push(v2 > v1 ? 1 : 0);
    10141037                        break;
    10151038
    10161039                case S_OPCODE_LTE:
    1017                         v1 = stack.pop();
    1018                         v2 = stack.pop();
     1040                        v1 = stack.top();
     1041                        stack.pop();
     1042                        v2 = stack.top();
     1043                        stack.pop();
    10191044                        stack.push(v2 <= v1 ? 1 : 0);
    10201045                        break;
    10211046
    10221047                case S_OPCODE_GTE:
    1023                         v1 = stack.pop();
    1024                         v2 = stack.pop();
     1048                        v1 = stack.top();
     1049                        stack.pop();
     1050                        v2 = stack.top();
     1051                        stack.pop();
    10251052                        stack.push(v2 >= v1 ? 1 : 0);
    10261053                        break;
    10271054
    10281055                case S_OPCODE_AND:
    1029                         stack.push(stack.pop() & stack.pop());
     1056                        v1 = stack.top();
     1057                        stack.pop();
     1058                        v2 = stack.top();
     1059                        stack.pop();
     1060                        stack.push(v1 & v2);
    10301061                        break;
    10311062
    10321063                case S_OPCODE_OR:
    1033                         stack.push(stack.pop() | stack.pop());
     1064                        v1 = stack.top();
     1065                        stack.pop();
     1066                        v2 = stack.top();
     1067                        stack.pop();
     1068                        stack.push(v1 | v2);
    10341069                        break;
    10351070
    10361071                case S_OPCODE_LOGICAL_AND:
    1037                         v1 = stack.pop();
    1038                         v2 = stack.pop();
     1072                        v1 = stack.top();
     1073                        stack.pop();
     1074                        v2 = stack.top();
     1075                        stack.pop();
    10391076                        stack.push(((v1 != 0) && (v2 != 0)) ? 1 : 0);
    10401077                        break;
    10411078
    10421079                case S_OPCODE_LOGICAL_OR:
    1043                         v1 = stack.pop();
    1044                         v2 = stack.pop();
     1080                        v1 = stack.top();
     1081                        stack.pop();
     1082                        v2 = stack.top();
     1083                        stack.pop();
    10451084                        stack.push(((v1 != 0) || (v2 != 0)) ? 1 : 0);
    10461085                        break;
    10471086
     
    10531092
    10541093                case S_OPCODE_SET_FIELD:
    10551094                        fieldNum = param >> 1;
    1056                         v1 = stack.pop();
     1095                        v1 = stack.top();
     1096                        stack.pop();
    10571097                        fields.setField(fieldNum, v1);
    10581098                        break;
    10591099
     
    10961136                        }
    10971137
    10981138                        param1 = 0; param2 = 0; param3 = 0;
    1099                         if (!stack.empty()) param1 = stack.pop();
    1100                         if (!stack.empty()) param2 = stack.pop();
    1101                         if (!stack.empty()) param3 = stack.pop();
     1139                        if (!stack.empty()) {
     1140                                param1 = stack.top();
     1141                                stack.pop();
     1142                        }
     1143                        if (!stack.empty()) {
     1144                                param2 = stack.top();
     1145                                stack.pop();
     1146                        }
     1147                        if (!stack.empty()) {
     1148                                param3 = stack.top();
     1149                                stack.pop();
     1150                        }
    11021151
    11031152                        if (rec->methodIndex == 0xff)
    11041153                                warning("Undefined script method %d", param);
     
    11091158                        break;
    11101159
    11111160                case S_OPCODE_COND_JUMP:
    1112                         v1 = stack.pop();
     1161                        v1 = stack.top();
     1162                        stack.pop();
    11131163                        if (v1 == 0) offset += (int16) param;
    11141164                        break;
    11151165
     
    11231173
    11241174                case S_OPCODE_END:
    11251175                        // Signal to end the execution
    1126                         if (!methodStack.empty())
    1127                                 offset = methodStack.pop();
    1128                         else
     1176                        if (!methodStack.empty()) {
     1177                                offset = methodStack.top();
     1178                                methodStack.pop();
     1179                        } else
    11291180                                breakFlag = true;
    11301181                        break;
    11311182
  • engines/parallaction/parallaction.cpp

     
    606606void Parallaction::popParserTables() {
    607607        assert(_opcodes.size() > 0);
    608608
    609         _currentOpcodes = _opcodes.pop();
    610         _currentStatements = _statements.pop();
     609        _currentOpcodes = _opcodes.top();
     610        _opcodes.pop();
     611        _currentStatements = _statements.top();
     612        _statements.pop();
    611613}
    612614
    613615void Parallaction::parseStatement() {
  • common/stack.h

     
    102102                const int s = size();
    103103                return _stack[s - 1];
    104104        }
    105         T pop() {
    106                 T tmp = top();
     105        void pop() {
    107106                _stack.remove_at(size() - 1);
    108                 return tmp;
    109107        }
    110108        int size() const {
    111109                return _stack.size();
  • common/array.h

     
    2727
    2828#include "common/scummsys.h"
    2929#include "common/algorithm.h"
     30#include "common/noncopyable.h"
    3031
    3132namespace Common {
    3233
     
    5253                copy(array._data, array._data + _size, _data);
    5354        }
    5455
    55         ~Array() {
    56                 delete [] _data;
     56        virtual ~Array() {
     57                clear();
    5758        }
    5859
    5960        void push_back(const T& element) {
     
    6768                _size += array._size;
    6869        }
    6970
    70         void insert_at(int idx, const T& element) {
    71                 assert(idx >= 0 && (uint)idx <= _size);
     71        void insert_at(uint idx, const T& element) {
     72                assert(idx <= _size);
    7273                ensureCapacity(_size + 1);
    7374                copy_backward(_data + idx, _data + _size, _data + _size + 1);
    7475                _data[idx] = element;
    7576                _size++;
    7677        }
    7778
    78         T remove_at(int idx) {
    79                 assert(idx >= 0 && (uint)idx < _size);
    80                 T tmp = _data[idx];
     79        virtual void remove_at(uint idx) {
     80                assert(idx < _size);
    8181                copy(_data + idx + 1, _data + _size, _data + idx);
    8282                _size--;
    83                 return tmp;
    8483        }
    8584
    8685        // TODO: insert, remove, ...
    8786
    88         T& operator [](int idx) {
    89                 assert(idx >= 0 && (uint)idx < _size);
     87        T& operator [](uint idx) {
     88                assert(idx < _size);
    9089                return _data[idx];
    9190        }
    9291
    93         const T& operator [](int idx) const {
    94                 assert(idx >= 0 && (uint)idx < _size);
     92        const T& operator [](uint idx) const {
     93                assert(idx < _size);
    9594                return _data[idx];
    9695        }
    9796
     
    112111                return _size;
    113112        }
    114113
    115         void clear() {
     114        virtual void clear() {
    116115                delete [] _data;
    117116                _data = 0;
    118117                _size = 0;
     
    182181        }
    183182};
    184183
     184template<class T>
     185class ManagedArray : public Array<T*>, public NonCopyable {
     186private:
     187        typedef Array<T*> Base;
     188
     189        class PtrEq {
     190        private:
     191                const T &_key;
     192
     193        public:
     194                PtrEq(const T &key) : _key(key) { }
     195
     196                bool operator ()(const T* item) {
     197                        assert(item);
     198                        return _key == *item;
     199                }
     200        };
     201public:
     202        typedef typename Array<T*>::iterator iterator;
     203        typedef typename Array<T*>::const_iterator const_iterator;
     204        typedef typename Array<T*>::value_type value_type;
     205
     206        virtual void remove_at(uint idx) {
     207                delete Base::operator [](idx);
     208                Base::remove_at(idx);
     209        }
     210
     211        void extract(uint idx) {
     212                Base::remove_at(idx);
     213        }
     214
     215        bool contains(const T &key) {
     216                return find_if(Base::begin(), Base::end(), PtrEq(key)) != Base::end();
     217        }
     218
     219        virtual void clear() {
     220                for (iterator i = Base::begin(); i != Base::end(); i++) {
     221                        delete *i;
     222                }
     223
     224                Base::clear();
     225        }
     226};
     227
    185228} // End of namespace Common
    186229
    187230#endif
  • graphics/cursorman.cpp

     
    7272        if (_cursorStack.empty())
    7373                return;
    7474
    75         Cursor *cur = _cursorStack.pop();
     75        Cursor *cur = _cursorStack.top();
     76        _cursorStack.pop();
    7677        delete cur;
    7778
    7879        if (!_cursorStack.empty()) {
     
    144145        if (_cursorPaletteStack.empty())
    145146                return;
    146147
    147         Palette *pal = _cursorPaletteStack.pop();
     148        Palette *pal = _cursorPaletteStack.top();
     149        _cursorPaletteStack.pop();
    148150        delete pal;
    149151
    150152        if (_cursorPaletteStack.empty()) {