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