import { Observable } from "../../util/observe";
import { CPPObject, AutoObject, StringLiteralObject, StaticObject, TemporaryObject, DynamicObject, InvalidObject, ArraySubobject } from "./objects";
import { ObjectPointerType, ArrayPointerType, PointerType, ArrayElemType, ReferenceType, CompleteObjectType } from "../compilation/types";
import { GlobalObjectEntity, LocalObjectEntity, LocalReferenceEntity, TemporaryObjectEntity } from "../compilation/entities";
import { RuntimeConstruct } from "../constructs/CPPConstruct";
import { CompiledGlobalVariableDefinition } from "../constructs/declarations/variable/GlobalVariableDefinition";
import { RuntimeFunction } from "../compilation/functions";
import { RawValueType, Value } from "./Value";
export declare type byte = number;
export declare class Memory {
    private static _name;
    readonly observable: Observable<string>;
    readonly capacity: number;
    readonly staticCapacity: number;
    readonly stackCapacity: number;
    readonly heapCapacity: number;
    readonly staticStart: number;
    readonly staticEnd: number;
    readonly stackStart: number;
    readonly stackEnd: number;
    readonly heapStart: number;
    readonly heapEnd: number;
    readonly temporaryStart: number;
    readonly temporaryCapacity: number;
    readonly temporaryEnd: number;
    private bytes;
    private objects;
    private stringLiteralMap;
    private staticObjects;
    private temporaryObjects;
    readonly stack: MemoryStack;
    readonly heap: MemoryHeap;
    private staticTop;
    private temporaryBottom;
    constructor(capacity?: number, staticCapacity?: number, stackCapacity?: number);
    reset(): void;
    getByte(addr: number): number;
    readByte(addr: number): number;
    getBytes(addr: number, num: number): number[];
    readBytes(addr: number, num: number): number[];
    setByte(addr: number, value: RawValueType): void;
    writeByte(addr: number, value: RawValueType): void;
    setBytes(addr: number, values: RawValueType[]): void;
    writeBytes(addr: number, values: RawValueType[]): void;
    dereference<Elem_type extends ArrayElemType>(ptr: Value<ArrayPointerType<Elem_type>>): ArraySubobject<Elem_type>;
    dereference<T extends CompleteObjectType>(ptr: Value<ObjectPointerType<T>>): CPPObject<T>;
    dereference<T extends CompleteObjectType>(ptr: Value<PointerType<T>>): CPPObject<T> | InvalidObject<T>;
    allLiveObjects(): CPPObject<CompleteObjectType>[];
    allocateObject(object: CPPObject<CompleteObjectType>): void;
    /**
     * Ends the lifetime of an object. Its data actually remains in memory, but is marked as dead and invalid.
     * If the object is already dead, does nothing.
     * @param addr
     * @param killer The runtime construct that killed the object
     */
    killObject(obj: CPPObject, killer?: RuntimeConstruct): void;
    /**
     * Allocates and returns a string literal object, unless a string literal with exactly
     * the same contents has already been allocated, in which case that same object is returned.
     * @param contents
     */
    allocateStringLiteral(contents: string): StringLiteralObject;
    getStringLiteral(str: string): StringLiteralObject | undefined;
    allocateStatic(def: CompiledGlobalVariableDefinition): void;
    staticLookup<T extends CompleteObjectType>(staticEntity: GlobalObjectEntity<T>): StaticObject<T>;
    allocateTemporaryObject<T extends CompleteObjectType>(tempEntity: TemporaryObjectEntity<T>): TemporaryObject<T>;
    deallocateTemporaryObject(obj: TemporaryObject, killer?: RuntimeConstruct): void;
    printObjects(): string;
}
declare class MemoryStack {
    private static readonly _name;
    readonly observable: Observable<string>;
    private top;
    private readonly start;
    private readonly memory;
    private readonly _frames;
    readonly frames: readonly MemoryFrame[];
    constructor(memory: Memory, start: number);
    topFrame(): MemoryFrame | undefined;
    pushFrame(rtFunc: RuntimeFunction): MemoryFrame;
    popFrame(rtConstruct: RuntimeConstruct): undefined;
    toString(): string;
}
declare class MemoryHeap {
    private static readonly _name;
    readonly observable: Observable<string>;
    private bottom;
    private readonly end;
    private readonly memory;
    readonly objectMap: {
        [index: number]: DynamicObject;
    };
    constructor(memory: Memory, end: number);
    allocateNewObject<T extends CompleteObjectType>(type: T): DynamicObject<T>;
    deleteObject(obj: DynamicObject, killer?: RuntimeConstruct): DynamicObject<CompleteObjectType>;
    deleteByAddress(addr: number, killer?: RuntimeConstruct): DynamicObject<CompleteObjectType>;
}
export declare class MemoryFrame {
    private static readonly _name;
    readonly observable: Observable<"referenceBound">;
    private readonly start;
    private readonly end;
    private readonly memory;
    readonly func: RuntimeFunction;
    readonly size: number;
    readonly localObjects: readonly AutoObject[];
    readonly localObjectsByName: {
        [index: string]: AutoObject | undefined;
    };
    private readonly localObjectsByEntityId;
    private readonly localReferencesByEntityId;
    private readonly localReferenceEntities;
    constructor(memory: Memory, start: number, rtFunc: RuntimeFunction);
    toString(): string;
    localObjectLookup<T extends CompleteObjectType>(entity: LocalObjectEntity<T>): AutoObject<T>;
    localReferenceLookup<T extends CompleteObjectType>(entity: LocalReferenceEntity<ReferenceType<T>>): CPPObject<T> | undefined;
    bindLocalReference(entity: LocalReferenceEntity, obj: CPPObject): void;
}
export {};