script.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_SCRIPT_H
#define SCI_ENGINE_SCRIPT_H
 
#include "common/str.h"
#include "sci/util.h"
#include "sci/engine/segment.h"
#include "sci/engine/script_patches.h"
 
namespace Sci {
 
struct EngineState;
class ResourceManager;
struct SciScriptPatcherEntry;
 
enum ScriptObjectTypes {
    SCI_OBJ_TERMINATOR,
    SCI_OBJ_OBJECT,
    SCI_OBJ_CODE,
    SCI_OBJ_SYNONYMS,
    SCI_OBJ_SAID,
    SCI_OBJ_STRINGS,
    SCI_OBJ_CLASS,
    SCI_OBJ_EXPORTS,
    SCI_OBJ_POINTERS,
    SCI_OBJ_PRELOAD_TEXT, /* This is really just a flag. */
    SCI_OBJ_LOCALVARS
};
 
typedef Common::HashMap<uint32, Object> ObjMap;
 
enum ScriptOffsetEntryTypes {
    SCI_SCR_OFFSET_TYPE_OBJECT = 0, // classes are handled by this type as well
    SCI_SCR_OFFSET_TYPE_STRING,
    SCI_SCR_OFFSET_TYPE_SAID
};
 
enum : uint {
    kNoRelocation = 0xFFFFFFFF
};
 
struct offsetLookupArrayEntry {
    uint16    type;       // type of entry
    uint16    id;         // id of this type, first item inside script data is 1, second item is 2, etc.
    uint32    offset;     // offset of entry within script resource data
    uint16    stringSize; // size of string, including terminating [NUL]
};
 
typedef Common::Array<offsetLookupArrayEntry> offsetLookupArrayType;
 
class Script : public SegmentObj {
private:
    int _nr; 
    Common::SpanOwner<SciSpan<byte> > _buf; 
    SciSpan<byte> _script; 
    SciSpan<byte> _heap; 
    uint _lockers; 
    SciSpan<const uint16> _exports; 
    uint16 _numExports; 
    SciSpan<const byte> _synonyms; 
    uint16 _numSynonyms; 
    int _codeOffset; 
    int _localsOffset;
    uint16 _localsCount;
 
    bool _markedAsDeleted;
    SegmentId _localsSegment; 
    LocalVariables *_localsBlock;
 
    ObjMap _objects;    
protected:
    offsetLookupArrayType _offsetLookupArray; // Table of all elements of currently loaded script, that may get pointed to
 
private:
    uint16 _offsetLookupObjectCount;
    uint16 _offsetLookupStringCount;
    uint16 _offsetLookupSaidCount;
 
public:
    int getLocalsOffset() const { return _localsOffset; }
    uint16 getLocalsCount() const { return _localsCount; }
 
    uint32 getScriptSize() const { return _script.size(); }
    uint32 getHeapSize() const { return _heap.size(); }
    uint32 getBufSize() const { return _buf->size(); }
    inline uint32 getHeapOffset() const {
        if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1_LATE) {
            return _script.size();
        }
 
        return 0;
    }
 
    const byte *getBuf(uint offset = 0) const { return _buf->getUnsafeDataAt(offset); }
    SciSpan<const byte> getSpan(uint offset) const { return _buf->subspan(offset); }
 
    int getScriptNumber() const { return _nr; }
    SegmentId getLocalsSegment() const { return _localsSegment; }
    reg_t *getLocalsBegin() { return _localsBlock ? _localsBlock->_locals.begin() : NULL; }
    void syncLocalsBlock(SegManager *segMan);
    ObjMap &getObjectMap() { return _objects; }
    const ObjMap &getObjectMap() const { return _objects; }
 
    // speed optimization: inline due to frequent calling
    bool offsetIsObject(uint32 offset) const {
        return _buf->getUint16SEAt(offset + SCRIPT_OBJECT_MAGIC_OFFSET) == SCRIPT_OBJECT_MAGIC_NUMBER;
    }
 
public:
    Script();
    ~Script() override;
 
    void freeScript(const bool keepLocalsSegment = false);
    void load(int script_nr, ResourceManager *resMan, ScriptPatcher *scriptPatcher, bool applyScriptPatches = true);
 
    bool isValidOffset(uint32 offset) const override;
    SegmentRef dereference(reg_t pointer) override;
    reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr) const override;
    void freeAtAddress(SegManager *segMan, reg_t sub_addr) override;
    Common::Array<reg_t> listAllDeallocatable(SegmentId segId) const override;
    Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const override;
 
    Common::Array<reg_t> listObjectReferences() const;
 
    void saveLoadWithSerializer(Common::Serializer &ser) override;
 
    Object *getObject(uint32 offset);
    const Object *getObject(uint32 offset) const;
 
    Object *scriptObjInit(reg_t obj_pos, bool fullObjectInit = true);
 
    void initializeLocals(SegManager *segMan);
 
    void initializeClass(SegManager *segMan, uint16 species, uint32 position);
 
    void initializeObjects(SegManager *segMan, SegmentId segmentId, bool applyScriptPatches);
 
    // script lock operations
 
    void incrementLockers();
 
    void decrementLockers();
 
    uint getLockers() const;
 
    void setLockers(uint lockers);
 
    uint getExportsOffset() const { return _exports.sourceByteOffset(); }
 
    uint16 getExportsNr() const { return _numExports; }
 
    const SciSpan<const byte> &getSynonyms() const { return _synonyms; }
 
    uint16 getSynonymsNr() const { return _numSynonyms; }
 
    uint32 validateExportFunc(int pubfunct, bool relocSci3);
 
    void markDeleted() {
        _markedAsDeleted = true;
    }
 
    bool isMarkedAsDeleted() const {
        return _markedAsDeleted;
    }
 
    SciSpan<const byte> findBlockSCI0(ScriptObjectTypes type, bool findLastBlock = false) const;
 
    void syncStringHeap(Common::Serializer &ser);
 
#ifdef ENABLE_SCI32
    int relocateOffsetSci3(uint32 offset) const;
#endif
 
    int getCodeBlockOffset() { return _codeOffset; }
 
    const offsetLookupArrayType *getOffsetArray() { return &_offsetLookupArray; };
    uint16 getOffsetObjectCount() { return _offsetLookupObjectCount; };
    uint16 getOffsetStringCount() { return _offsetLookupStringCount; };
    uint16 getOffsetSaidCount() { return _offsetLookupSaidCount; };
 
    uint32 getRelocationOffset(const uint32 offset) const;
 
private:
    const SciSpan<const uint16> getRelocationTableSci0Sci21() const;
 
    void relocateSci0Sci21(const SegmentId segmentId);
 
#ifdef ENABLE_SCI32
    void relocateSci3(const SegmentId segmentId);
#endif
 
    bool relocateLocal(SegmentId segment, int location, uint32 offset);
 
#ifdef ENABLE_SCI32
    SciSpan<const byte> getSci3ObjectsPointer();
#endif
 
    void initializeObjectsSci0(SegManager *segMan, SegmentId segmentId, bool applyScriptPatches);
 
    void initializeObjectsSci11(SegManager *segMan, SegmentId segmentId, bool applyScriptPatches);
 
#ifdef ENABLE_SCI32
    void initializeObjectsSci3(SegManager *segMan, SegmentId segmentId, bool applyScriptPatches);
#endif
 
    LocalVariables *allocLocalsSegment(SegManager *segMan);
 
    void identifyOffsets();
 
    void applySaidWorkarounds();
};
 
} // End of namespace Sci
 
#endif // SCI_ENGINE_SCRIPT_H