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