root/trunk/minid/types.d

/******************************************************************************
License:
Copyright (c) 2008 Jarrett Billingsley

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the
use of this software.

Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:

    1. The origin of this software must not be misrepresented; you must not
    claim that you wrote the original software. If you use this software in a
    product, an acknowledgment in the product documentation would be
    appreciated but is not required.

    2. Altered source versions must be plainly marked as such, and must not
    be misrepresented as being the original software.

    3. This notice may not be removed or altered from any source distribution.
******************************************************************************/

module minid.types;

version(MDRestrictedCoro) {} else
    import tango.core.Thread;

import tango.text.convert.Layout;

import minid.alloc;
import minid.hash;
import minid.opcodes;
import minid.utils;

import tango.text.convert.Format;

// ================================================================================================================================================
// Public
// ================================================================================================================================================

/**
The native signed integer type on this platform.  This is the same as ptrdiff_t but with a better name.
*/
public alias ptrdiff_t word;

/**
The native unsigned integer type on this platform.  This is the same as size_t but with a better name.
*/
public alias size_t uword;

/**
The underlying D type used to store the MiniD 'int' type.  Defaults to 'long' (64-bit signed integer).  If you
change it, you will end up with a functional but nonstandard implementation.
*/
public alias long mdint;

static assert((cast(mdint)-1) < (cast(mdint)0), "mdint must be signed");

/**
The underlying D type used to store the MiniD 'float' type.  Defaults to 'double'.  If you change it, you will end
up with a functional but nonstandard implementation.
*/
public alias double mdfloat;

/**
The current version of MiniD.
*/
public const uint MiniDVersion = MakeVersion!(2, 0);

/**
An alias for the type signature of a native function.  It is defined as uword function(MDThread*, uword).
*/
public alias uword function(MDThread*, uword) NativeFunc;

/**
The MiniD exception type.  This is the type that is thrown whenever you throw an exception from within
MiniD, or when you use the throwException API call.  You can't directly instantiate this class, though,
since it would be bad if you did (the interpreter needs to keep track of some internal state, which
throwException does).  See throwException and catchException in minid.interpreter for more info
on MiniD exception handling.
*/
class MDException : Exception
{
    package this(char[] msg)
    {
        super(msg);
    }
}

/**
This is a semi-internal exception type.  Normally you won't need to know about it or catch it.  This is
thrown when a coroutine (thread) needs to be halted.  It should never propagate out of the coroutine.
The only time you might encounter it is if, in the middle of a native MiniD function, one of these
is thrown, you might be able to catch it and clean up some resources, but you should rethrow it.

Like the other exception types, you can't instantiate this directly, but you can halt threads with the
"haltThread" function in minid.interpreter.
*/
final class MDHaltException : Exception
{
    package this()
    {
        super("MiniD interpreter halted");
    }
}

/**
A string constant indicating the level of coroutine support compiled in.  Is one of "Restricted",
"Normal", or "Extended".
*/
version(MDRestrictedCoro)
{
    version(MDExtendedCoro)
    {
        pragma(msg, "The 'MDRestrictedCoro' and 'MDExtendedCoro' versions are mutually exclusive.");
        pragma(msg, "Please define one or the other (or neither), not both.\n");
        static assert(false, "FAILCOPTER.");
    }

    const char[] MDCoroSupport = "Restricted";
}
else version(MDExtendedCoro)
    const char[] MDCoroSupport = "Extended";
else
    const char[] MDCoroSupport = "Normal";

// ================================================================================================================================================
// Package
// ================================================================================================================================================

align(1) struct MDValue
{
    enum Type : uint
    {
        // Value Types
        Null, // 0
        Bool,
        Int,
        Float,
        Char,

        // Reference Types
        String, // 5
        Table,
        Array,
        Function,
        Class,
        Instance, // 10
        Namespace,
        Thread,
        NativeObj,
        WeakRef,

        // Internal types
        Upvalue, // 15
        FuncDef,
        ArrayData
    }

    package static char[] typeString(MDValue.Type t)
    {
        switch(t)
        {
            case Type.Null:      return "null";
            case Type.Bool:      return "bool";
            case Type.Int:       return "int";
            case Type.Float:     return "float";
            case Type.Char:      return "char";

            case Type.String:    return "string";
            case Type.Table:     return "table";
            case Type.Array:     return "array";
            case Type.Function:  return "function";
            case Type.Class:     return "class";
            case Type.Instance:  return "instance";
            case Type.Namespace: return "namespace";
            case Type.Thread:    return "thread";
            case Type.NativeObj: return "nativeobj";
            case Type.WeakRef:   return "weakref";

            case Type.Upvalue:   return "upvalue";
            case Type.FuncDef:   return "funcdef";
            case Type.ArrayData: return "arraydata";

            default: assert(false);
        }
    }

    package static MDValue nullValue = { type : Type.Null, mInt : 0 };

    package Type type = Type.Null;

    union
    {
        package bool mBool;
        package mdint mInt;
        package mdfloat mFloat;
        package dchar mChar;

        package MDBaseObject* mBaseObj;
        package MDString* mString;
        package MDTable* mTable;
        package MDArray* mArray;
        package MDFunction* mFunction;
        package MDClass* mClass;
        package MDInstance* mInstance;
        package MDNamespace* mNamespace;
        package MDThread* mThread;
        package MDNativeObj* mNativeObj;
        package MDWeakRef* mWeakRef;
    }

    package static MDValue opCall(T)(T t)
    {
        MDValue ret = void;
        ret = t;
        return ret;
    }

    /*
    Returns true if this and the other value are exactly the same type and the same value.  The semantics
    of this are exactly the same as the 'is' expression in MiniD.
    */
    package int opEquals(ref MDValue other)
    {
        if(this.type != other.type)
            return false;

        switch(this.type)
        {
            case Type.Null: return true;
            case Type.Bool: return this.mBool == other.mBool;
            case Type.Int: return this.mInt == other.mInt;
            case Type.Float: return this.mFloat == other.mFloat;
            case Type.Char: return this.mChar == other.mChar;
            default: return (this.mBaseObj is other.mBaseObj);
        }
    }

    package bool isFalse()
    {
        return (type == Type.Null) || (type == Type.Bool && mBool == false) ||
            (type == Type.Int && mInt == 0) || (type == Type.Float && mFloat == 0.0) || (type == Type.Char && mChar != 0);
    }
    
    package void opAssign(bool src)
    {
        type = Type.Bool;
        mBool = src;
    }
    
    package void opAssign(mdint src)
    {
        type = Type.Int;
        mInt = src;
    }
    
    package void opAssign(mdfloat src)
    {
        type = Type.Float;
        mFloat = src;
    }
    
    package void opAssign(dchar src)
    {
        type = Type.Char;
        mChar = src;
    }
    
    package void opAssign(MDString* src)
    {
        type = Type.String;
        mString = src;
    }
    
    package void opAssign(MDTable* src)
    {
        type = Type.Table;
        mTable = src;
    }
    
    package void opAssign(MDArray* src)
    {
        type = Type.Array;
        mArray = src;
    }

    package void opAssign(MDFunction* src)
    {
        type = Type.Function;
        mFunction = src;
    }
    
    package void opAssign(MDClass* src)
    {
        type = Type.Class;
        mClass = src;
    }
    
    package void opAssign(MDInstance* src)
    {
        type = Type.Instance;
        mInstance = src;
    }

    package void opAssign(MDNamespace* src)
    {
        type = Type.Namespace;
        mNamespace = src;
    }

    package void opAssign(MDThread* src)
    {
        type = Type.Thread;
        mThread = src;
    }
    
    package void opAssign(MDNativeObj* src)
    {
        type = Type.NativeObj;
        mNativeObj = src;
    }
    
    package void opAssign(MDWeakRef* src)
    {
        type = Type.WeakRef;
        mWeakRef = src;
    }

    package void opAssign(MDBaseObject* src)
    {
        type = src.mType;
        mBaseObj = src;
    }

    package bool isObject()
    {
        return type >= Type.String;
    }

    package GCObject* toGCObject()
    {
        assert(isObject());
        return cast(GCObject*)mBaseObj;
    }

    char[] toString()
    {
        switch(type)
        {
            case Type.Null:      return "null";
            case Type.Bool:      return Format("{}", mBool);
            case Type.Int:       return Format("{}", mInt);
            case Type.Float:     return Format("{}", mFloat);
            case Type.Char:      return Format("'{}'", mChar);
            case Type.String:    return Format("\"{}\"", mString.toString());
            case Type.Table:     return Format("table {:X8}", cast(void*)mTable);
            case Type.Array:     return Format("array {:X8}", cast(void*)mArray);
            case Type.Function:  return Format("function {:X8}", cast(void*)mFunction);
            case Type.Class:     return Format("class {:X8}", cast(void*)mClass);
            case Type.Instance:  return Format("instance {:X8}", cast(void*)mInstance);
            case Type.Namespace: return Format("namespace {:X8}", cast(void*)mNamespace);
            case Type.Thread:    return Format("thread {:X8}", cast(void*)mThread);
            case Type.NativeObj: return Format("nativeobj {:X8}", cast(void*)mNativeObj);
            case Type.WeakRef:   return Format("weakref {:X8}", cast(void*)mWeakRef);
            default: assert(false);
        }
    }

    hash_t toHash()
    {
        switch(type)
        {
            case Type.Null:   return 0;
            case Type.Bool:   return typeid(typeof(mBool)).getHash(&mBool);
            case Type.Int:    return typeid(typeof(mInt)).getHash(&mInt);
            case Type.Float:  return typeid(typeof(mFloat)).getHash(&mFloat);
            case Type.Char:   return typeid(typeof(mChar)).getHash(&mChar);
            case Type.String: return mString.hash;
            default:          return cast(hash_t)cast(void*)mBaseObj;
        }
    }
}

template MDObjectMixin(uint type)
{
    mixin GCMixin;
    package MDValue.Type mType = cast(MDValue.Type)type;
}

struct MDBaseObject
{
    mixin MDObjectMixin!(MDValue.Type.Null);
}

struct MDString
{
    mixin MDObjectMixin!(MDValue.Type.String);
    package uword hash;
    package uword length;
    package uword cpLength;

    package char[] toString()
    {
        return (cast(char*)(this + 1))[0 .. this.length];
    }
    
    package uint toHash()
    {
        return hash;
    }
}

struct MDTable
{
    mixin MDObjectMixin!(MDValue.Type.Table);
    package Hash!(MDValue, MDValue) data;
}

struct MDArrayData
{
    mixin MDObjectMixin!(MDValue.Type.ArrayData);
    package uword length;

    package MDValue[] toArray()
    {
        return (cast(MDValue*)(this + 1))[0 .. length];
    }
}

struct MDArray
{
    mixin MDObjectMixin!(MDValue.Type.Array);
    package MDArrayData* data;
    package MDValue[] slice;
    package bool isSlice;
}

struct MDFunction
{
    mixin MDObjectMixin!(MDValue.Type.Function);
    package bool isNative;
    package MDNamespace* environment;
    package MDString* name;
    package uword numUpvals;
    package MDTable* attrs;

    union
    {
        package MDFuncDef* scriptFunc;
        package NativeFunc nativeFunc;
    }

    package MDValue[] nativeUpvals()
    {
        return (cast(MDValue*)(this + 1))[0 .. numUpvals];
    }

    package MDUpval*[] scriptUpvals()
    {
        return (cast(MDUpval**)(this + 1))[0 .. numUpvals];
    }

    static assert((MDFuncDef*).sizeof == NativeFunc.sizeof);
}

struct MDClass
{
    mixin MDObjectMixin!(MDValue.Type.Class);
    package MDString* name;
    package MDClass* parent;
    package MDNamespace* fields;
    package MDTable* attrs;
    package MDFunction* allocator;
    package MDFunction* finalizer;
}

struct MDInstance
{
    mixin MDObjectMixin!(MDValue.Type.Instance);
    package MDClass* parent;
    package MDNamespace* fields;
    package MDFunction* finalizer;
    package uword numValues;
    package uword extraBytes;
    
    package MDValue[] extraValues()
    {
        return (cast(MDValue*)(this + 1))[0 .. numValues];
    }
    
    package void[] extraData()
    {
        return ((cast(void*)(this + 1)) + (numValues * MDValue.sizeof))[0 .. extraBytes];
    }
}

struct MDNamespace
{
    mixin MDObjectMixin!(MDValue.Type.Namespace);
    package Hash!(MDString*, MDValue) data;
    package MDNamespace* parent;
    package MDString* name;
    package MDTable* attrs;
}

package alias uword AbsStack;
package alias uword RelStack;

struct ActRecord
{
    package AbsStack base;
    package AbsStack savedTop;
    package AbsStack vargBase;
    package AbsStack returnSlot;
    package MDFunction* func;
    package Instruction* pc;
    package word numReturns;
    package MDClass* proto;
    package uword numTailcalls;
    package uword firstResult;
    package uword numResults;
}

struct TryRecord
{
    package bool isCatch;
    package RelStack catchVarSlot;
    package uword actRecord;
    package Instruction* pc;
}

struct MDThread
{
    mixin MDObjectMixin!(MDValue.Type.Thread);

    public enum State
    {
        Initial,
        Waiting,
        Running,
        Suspended,
        Dead
    }

    static char[][5] StateStrings =
    [
        State.Initial: "initial",
        State.Waiting: "waiting",
        State.Running: "running",
        State.Suspended: "suspended",
        State.Dead: "dead"
    ];

    package TryRecord[] tryRecs;
    package TryRecord* currentTR;
    package uword trIndex = 0;

    package ActRecord[] actRecs;
    package ActRecord* currentAR;
    package uword arIndex = 0;

    package MDValue[] stack;
    package AbsStack stackIndex;
    package AbsStack stackBase;

    package MDValue[] results;
    package uword resultIndex = 0;

    package MDUpval* upvalHead;
    
    package MDVM* vm;
    package bool shouldHalt = false;

    package MDFunction* coroFunc;
    package State state = State.Initial;
    package uword numYields;

    version(MDExtendedCoro) {} else
    {
        package uword savedCallDepth;
        package uword nativeCallDepth = 0;
    }

    version(MDRestrictedCoro) {} else
    {
        // References a Fiber object
        package MDNativeObj* coroFiber;

        package Fiber getFiber()
        {
            assert(coroFiber !is null);
            return cast(Fiber)cast(void*)coroFiber.obj;
        }
    }
}

struct MDNativeObj
{
    mixin MDObjectMixin!(MDValue.Type.NativeObj);
    package Object obj;
}

struct MDWeakRef
{
    mixin MDObjectMixin!(MDValue.Type.WeakRef);
    package MDBaseObject* obj;
}

struct Location
{
    enum Type
    {
        Unknown = -2,
        Native = -1,
        Script = 0  
    }

    public MDString* file;
    // yes, these are 32 bits
    package int line = 1;
    package int col = 1;

    public static Location opCall(MDString* file, int line = 1, int col = 1)
    {
        Location l = void;
        l.file = file;
        l.line = line;
        l.col = col;
        return l;
    }
}

struct MDUpval
{
    mixin MDObjectMixin!(MDValue.Type.Upvalue);

    package MDValue* value;
    package MDValue closedValue;
    package MDUpval* nextuv;
}

// The integral members of this struct are fixed at 32 bits for possible cross-platform serialization.
struct MDFuncDef
{
    mixin MDObjectMixin!(MDValue.Type.FuncDef);

    package Location location;
    package bool isVararg;
    package MDString* name;
    package uint numParams;
    package ushort[] paramMasks;
    package uint numUpvals;
    package uint stackSize;
    package MDFuncDef*[] innerFuncs;
    package MDValue[] constants;
    package Instruction[] code;

    package bool isPure;
    package MDFunction* cachedFunc;

    struct SwitchTable
    {
        package Hash!(MDValue, word) offsets;
        package int defaultOffset = -1; // yes, this is 32 bit, it's fixed that size
    }

    package SwitchTable[] switchTables;

    // Debug info.
    package uint[] lineInfo;
    package MDString*[] upvalNames;

    struct LocVarDesc
    {
        package MDString* name;
        package uint pcStart;
        package uint pcEnd;
        package uint reg;
    }

    package LocVarDesc[] locVarDescs;
}

// please don't align(1) this struct, it'll mess up the D GC when it tries to look inside for pointers.
struct MDVM
{
    package Allocator alloc;

    package <