seg_manager.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef SCI_ENGINE_SEG_MANAGER_H
#define SCI_ENGINE_SEG_MANAGER_H
 
#include "common/scummsys.h"
#include "common/serializer.h"
#include "sci/engine/script.h"
#include "sci/engine/vm.h"
#include "sci/engine/vm_types.h"
#include "sci/engine/segment.h"
#ifdef ENABLE_SCI32
#include "sci/graphics/celobj32.h" // kLowResX, kLowResY
#endif
 
namespace Sci {
 
enum ScriptLoadType {
    SCRIPT_GET_DONT_LOAD = 0, 
    SCRIPT_GET_LOAD = 1, 
    SCRIPT_GET_LOCK = 3 
};
 
class Script;
 
class SegManager : public Common::Serializable {
    friend class Console;
public:
    SegManager(ResourceManager *resMan, ScriptPatcher *scriptPatcher);
 
    ~SegManager() override;
 
    void resetSegMan();
 
    void saveLoadWithSerializer(Common::Serializer &ser) override;
 
    // 1. Scripts
 
    Script *allocateScript(int script_nr, SegmentId &seg_id);
 
    // The script must then be initialized; see section (1b.), below.
 
    void deallocateScript(int script_nr);
 
    void reconstructStack(EngineState *s);
 
    SegmentId getScriptSegment(int script_nr) const;
 
    SegmentId getScriptSegment(int script_nr, ScriptLoadType load, bool applyScriptPatches = true);
 
    int instantiateScript(int script_nr, bool applyScriptPatches = true);
 
    void uninstantiateScript(int script_nr);
 
private:
    void uninstantiateScriptSci0(int script_nr);
 
public:
    // TODO: document this
    reg_t getClassAddress(int classnr, ScriptLoadType lock, uint16 callerSegment, bool applyScriptPatches = true);
 
    Script *getScript(SegmentId seg);
 
 
    Script *getScriptIfLoaded(SegmentId seg) const;
 
    // 2. Clones
 
    Clone *allocateClone(reg_t *addr);
 
    void reconstructClones();
 
    // 4. Stack
 
    DataStack *allocateStack(int size);
 
 
    // 5. System Strings
 
    void initSysStrings();
 
 
    // 6, 7. Lists and Nodes
 
    List *allocateList(reg_t *addr);
 
    Node *allocateNode(reg_t *addr);
 
    reg_t newNode(reg_t value, reg_t key);
 
    List *lookupList(reg_t addr);
 
    Node *lookupNode(reg_t addr, bool stopOnDiscarded = true);
 
 
    // 8. Hunk Memory
 
    reg_t allocateHunkEntry(const char *hunk_type, int size);
 
    void freeHunkEntry(reg_t addr);
 
    byte *getHunkPointer(reg_t addr);
 
    // 9. Dynamic Memory
 
    byte *allocDynmem(int size, const char *description, reg_t *addr);
 
    bool freeDynmem(reg_t addr);
 
 
    // Generic Operations on Segments and Addresses
 
    SegmentRef dereference(reg_t pointer);
 
    byte *derefBulkPtr(reg_t pointer, int entries);
 
    reg_t *derefRegPtr(reg_t pointer, int entries);
 
    char *derefString(reg_t pointer, int entries = 0);
 
    Common::String getString(reg_t pointer);
 
 
    void strcpy_(reg_t dest, reg_t src);
 
    void strcpy_(reg_t dest, const char *src);
 
    void strncpy(reg_t dest, reg_t src, size_t n);
 
    void strncpy(reg_t dest, const char *src, size_t n);
 
    void memcpy(reg_t dest, reg_t src, size_t n);
 
    void memcpy(reg_t dest, const byte* src, size_t n);
 
    void memcpy(byte *dest, reg_t src, size_t n);
 
    size_t strlen(reg_t str);
 
    SegmentId findSegmentByType(int type) const;
 
    // TODO: document this
    SegmentObj *getSegmentObj(SegmentId seg) const;
 
    // TODO: document this
    SegmentType getSegmentType(SegmentId seg) const;
 
    // TODO: document this
    SegmentObj *getSegment(SegmentId seg, SegmentType type) const;
 
    Object *getObject(reg_t pos) const;
 
    bool isObject(reg_t obj) const { return getObject(obj) != NULL; }
 
    // TODO: document this
    bool isHeapObject(reg_t pos) const;
 
    const char *getObjectName(reg_t pos);
 
    Common::Array<reg_t> findObjectsByName(const Common::String &name);
 
    reg_t findObjectByName(const Common::String &name, int index = -1);
 
    Common::Array<reg_t> findObjectsBySuperClass(const Common::String &superClassName);
 
    uint32 classTableSize() const { return _classTable.size(); }
    Class getClass(int index) const { return _classTable[index]; }
    void setClassOffset(int index, reg_t offset) { _classTable[index].reg = offset; }
    void resizeClassTable(uint32 size) { _classTable.resize(size); }
 
    reg_t getSaveDirPtr() const { return _saveDirPtr; }
    reg_t getParserPtr() const { return _parserPtr; }
 
#ifdef ENABLE_SCI32
    bool isValidAddr(reg_t reg, SegmentType expected) const {
        SegmentObj *mobj = getSegmentObj(reg.getSegment());
        return (mobj &&
                mobj->getType() == expected &&
                mobj->isValidOffset(reg.getOffset()));
    }
 
    SciArray *allocateArray(SciArrayType type, uint16 size, reg_t *addr);
    SciArray *lookupArray(reg_t addr);
    void freeArray(reg_t addr);
    bool isArray(reg_t addr) const;
 
    SciBitmap *allocateBitmap(reg_t *addr, const int16 width, const int16 height, const uint8 skipColor = kDefaultSkipColor, const int16 originX = 0, const int16 originY = 0, const int16 xResolution = kLowResX, const int16 yResolution = kLowResY, const uint32 paletteSize = 0, const bool remap = false, const bool gc = true);
    SciBitmap *lookupBitmap(reg_t addr);
    void freeBitmap(reg_t addr);
#endif
 
    const Common::Array<SegmentObj *> &getSegments() const { return _heap; }
 
private:
    Common::Array<SegmentObj *> _heap;
    Common::Array<Class> _classTable; 
    Common::HashMap<int, SegmentId> _scriptSegMap;
 
    ResourceManager *_resMan;
    ScriptPatcher *_scriptPatcher;
 
    SegmentId _clonesSegId; 
    SegmentId _listsSegId; 
    SegmentId _nodesSegId; 
    SegmentId _hunksSegId; 
 
    // Statically allocated memory for system strings
    reg_t _saveDirPtr;
    reg_t _parserPtr;
 
#ifdef ENABLE_SCI32
    SegmentId _arraysSegId;
    SegmentId _bitmapSegId;
#endif
 
public:
    SegmentId allocSegment(SegmentObj *mobj);
 
private:
    void deallocate(SegmentId seg);
    void createClassTable();
 
    SegmentId findFreeSegment() const;
 
    SegmentId getActualSegment(SegmentId seg) const;
};
 
} // End of namespace Sci
 
#endif // SCI_ENGINE_SEG_MANAGER_H