runtime.hh

Go to the documentation of this file.

#pragma once

#include <stdint.h>
#include <assert.h>
#include <string>
#include "gc.h"

static_assert(sizeof(void*) == 8,
    "MysoreScript only supports 64-bit platforms currently");

namespace {
template<typename T>
T* gcAlloc(size_t extraBytes=0)
{
    size_t size = sizeof(T) + extraBytes;
    return reinterpret_cast<T*>(GC_MALLOC(size));
}
}
namespace AST
{
    struct ClosureDecl;
}

namespace MysoreScript
{

struct Object;
struct Closure;

typedef Object* Obj;
inline bool isInteger(Obj o)
{
    return (reinterpret_cast<intptr_t>(o) & 7) == 1;
}
inline intptr_t getInteger(Obj o)
{
    assert(isInteger(o));
    return reinterpret_cast<intptr_t>(o) >> 3;
}
inline Obj createSmallInteger(intptr_t i)
{
    // Small integers are 61-bits, assert that we won't overflow.
    assert((i<<3)>>3 == i);
    return reinterpret_cast<Obj>(((i << 3) | 1));
}

typedef uint32_t Selector;
typedef Object *(*CompiledMethod)(Object*,Selector,...);
typedef Object *(*ClosureInvoke)(Closure*,...);

struct Method
{
    Selector          selector;
    int32_t           args;
    CompiledMethod    function;
    AST::ClosureDecl *AST;
};

struct Class
{
    struct Class        *superclass;
    const char          *className;
    int32_t              methodCount;
    int32_t             indexedIVarCount;
    struct Method       *methodList;
    const char         **indexedIVarNames;
};

struct Object
{
    struct Class *isa;
};

struct Array
{
    Class    *isa;
    Obj       length;
    Obj       bufferSize;
    Obj      *buffer;
};

struct String
{
    Class    *isa;
    Obj       length;
    char      characters[0];
};

struct Closure
{
    Class             *isa;
    Obj                parameters;
    ClosureInvoke      invoke;
    AST::ClosureDecl  *AST;
    Obj                boundVars[0];
};

extern struct Class StringClass;
extern struct Class SmallIntClass;
extern struct Class ClosureClass;
void registerClass(const std::string &name, struct Class *cls);
struct Class* lookupClass(const std::string &name);



extern "C"
{
Obj newObject(struct Class *cls);
Obj mysoreScriptAdd(Obj lhs, Obj rhs);
Obj mysoreScriptSub(Obj lhs, Obj rhs);
Obj mysoreScriptMul(Obj lhs, Obj rhs);
Obj mysoreScriptDiv(Obj lhs, Obj rhs);
CompiledMethod compiledMethodForSelector(Obj obj, Selector sel);
}

Selector lookupSelector(const std::string &);
Method *methodForSelector(Class*, Selector);
Obj callCompiledMethod(CompiledMethod m, Obj receiver, Selector sel, Obj *args,
        int argCount);
Obj callCompiledClosure(ClosureInvoke m, Closure *receiver, Obj *args,
        int argCount);

}