root/trunk/minid/baselib.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.baselib;

import Float = tango.text.convert.Float;
import Integer = tango.text.convert.Integer;
import tango.io.Buffer;
import tango.io.Console;
import tango.io.Print;
import tango.io.Stdout;
import tango.stdc.ctype;
import Utf = tango.text.convert.Utf;

import minid.alloc;
import minid.classobj;
import minid.compiler;
import minid.ex;
import minid.instance;
import minid.interpreter;
import minid.misc;
import minid.string;
import minid.stringbuffer;
import minid.types;
import minid.utils;
import minid.vector;
import minid.vm;

private void register(MDThread* t, char[] name, NativeFunc func, uword numUpvals = 0)
{
    newFunction(t, func, name, numUpvals);
    newGlobal(t, name);
}

struct BaseLib
{
static:
    public void init(MDThread* t)
    {
        register(t, "collectGarbage", &collectGarbage);

        // Object
        pushClass(t, classobj.create(t.vm.alloc, string.create(t.vm, "Object"), null));
        newGlobal(t, "Object");
        
        // Vector
        VectorObj.init(t);

        // StringBuffer
        StringBufferObj.init(t);

        // Functional stuff
        register(t, "curry", &curry);
        register(t, "bindContext", &bindContext);

        // Reflection-esque stuff
        register(t, "findGlobal", &findGlobal);
        register(t, "isSet", &isSet);
        register(t, "typeof", &mdtypeof);
        register(t, "fieldsOf", &fieldsOf);
        register(t, "allFieldsOf", &allFieldsOf);
        register(t, "hasField", &hasField);
        register(t, "hasMethod", &hasMethod);
        register(t, "findField", &findField);
        register(t, "rawSetField", &rawSetField);
        register(t, "rawGetField", &rawGetField);
        register(t, "attrs", &attrs);
        register(t, "hasAttributes", &hasAttributes);
        register(t, "attributesOf", &attributesOf);
        register(t, "isNull", &isParam!(MDValue.Type.Null));
        register(t, "isBool", &isParam!(MDValue.Type.Bool));
        register(t, "isInt", &isParam!(MDValue.Type.Int));
        register(t, "isFloat", &isParam!(MDValue.Type.Float));
        register(t, "isChar", &isParam!(MDValue.Type.Char));
        register(t, "isString", &isParam!(MDValue.Type.String));
        register(t, "isTable", &isParam!(MDValue.Type.Table));
        register(t, "isArray", &isParam!(MDValue.Type.Array));
        register(t, "isFunction", &isParam!(MDValue.Type.Function));
        register(t, "isClass", &isParam!(MDValue.Type.Class));
        register(t, "isInstance", &isParam!(MDValue.Type.Instance));
        register(t, "isNamespace", &isParam!(MDValue.Type.Namespace));
        register(t, "isThread", &isParam!(MDValue.Type.Thread));
        register(t, "isNativeObj", &isParam!(MDValue.Type.NativeObj));
        register(t, "isWeakRef", &isParam!(MDValue.Type.WeakRef));

        // Conversions
        register(t, "toString", &toString);
        register(t, "rawToString", &rawToString);
        register(t, "toBool", &toBool);
        register(t, "toInt", &toInt);
        register(t, "toFloat", &toFloat);
        register(t, "toChar", &toChar);
        register(t, "format", &format);

        // Console IO
        register(t, "write", &write);
        register(t, "writeln", &writeln);
        register(t, "writef", &writef);
        register(t, "writefln", &writefln);
        register(t, "readln", &readln);

            newTable(t);
        register(t, "dumpVal", &dumpVal, 1);

        // Dynamic compilation stuff
        register(t, "loadString", &loadString);
        register(t, "eval", &eval);
        register(t, "loadJSON", &loadJSON);
        register(t, "toJSON", &toJSON);

        // The Function type's metatable
        newNamespace(t, "function");
            newFunction(t, &functionEnvironment, "function.environment"); fielda(t, -2, "environment");
            newFunction(t, &functionIsNative,    "function.isNative");    fielda(t, -2, "isNative");
            newFunction(t, &functionNumParams,   "function.numParams");   fielda(t, -2, "numParams");
            newFunction(t, &functionIsVararg,    "function.isVararg");    fielda(t, -2, "isVararg");
            newFunction(t, &functionName,        "function.name");        fielda(t, -2, "name");
        setTypeMT(t, MDValue.Type.Function);

        // Weak reference stuff
        register(t, "weakref", &weakref);
        register(t, "deref", &deref);

        newNamespace(t, "weakref");
            newFunction(t, &weakrefDeref,        "weakref.deref");        fielda(t, -2, "deref");
        setTypeMT(t, MDValue.Type.WeakRef);
    }

    uword collectGarbage(MDThread* t, uword numParams)
    {
        pushInt(t, gc(t));
        return 1;
    }
    
    // ===================================================================================================================================
    // Functional stuff

    uword curry(MDThread* t, uword numParams)
    {
        static uword call(MDThread* t, uword numParams)
        {
            getUpval(t, 0);
            dup(t, 0);
            getUpval(t, 1);
            rotateAll(t, 3);
            return rawCall(t, 1, -1);
        }

        checkParam(t, 1, MDValue.Type.Function);
        checkAnyParam(t, 2);
        setStackSize(t, 3);
        newFunction(t, &call, "curryClosure", 2);
        return 1;
    }

    uword bindContext(MDThread* t, uword numParams)
    {
        static uword call(MDThread* t, uword numParams)
        {
            getUpval(t, 0);
            getUpval(t, 1);
            rotateAll(t, 2);
            return rawCall(t, 1, -1);
        }

        checkParam(t, 1, MDValue.Type.Function);
        checkAnyParam(t, 2);
        setStackSize(t, 3);
        newFunction(t, &call, "boundFunction", 2);
        return 1;
    }

    // ===================================================================================================================================
    // Reflection-esque stuff

    uword findGlobal(MDThread* t, uword numParams)
    {
        if(!.findGlobal(t, checkStringParam(t, 1), 1))
            pushNull(t);

        return 1;
    }

    uword isSet(MDThread* t, uword numParams)
    {
        if(!.findGlobal(t, checkStringParam(t, 1), 1))
            pushBool(t, false);
        else
        {
            pop(t);
            pushBool(t, true);
        }

        return 1;
    }

    uword mdtypeof(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        pushString(t, MDValue.typeString(type(t, 1)));
        return 1;
    }

    uword fieldsOf(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        
        if(isClass(t, 1) || isInstance(t, 1))
            .fieldsOf(t, 1);
        else
            paramTypeError(t, 1, "class|instance");

        return 1;
    }

    uword allFieldsOf(MDThread* t, uword numParams)
    {
        // Upvalue 0 is the current object
        // Upvalue 1 is the current index into the namespace
        // Upvalue 2 is the duplicates table
        static uword iter(MDThread* t, uword numParams)
        {
            MDInstance* i;
            MDClass* c;
            MDString** key = void;
            MDValue* value = void;
            uword index = 0;

            while(true)
            {
                // Get the next field
                getUpval(t, 0);

                getUpval(t, 1);
                index = cast(uword)getInt(t, -1);
                pop(t);

                bool haveField = void;

                if(isInstance(t, -1))
                {
                    i = getInstance(t, -1);
                    c = null;
                    haveField = instance.next(i, index, key, value);
                }
                else
                {
                    c = getClass(t, -1);
                    i = null;
                    haveField = classobj.next(c, index, key, value);
                }

                if(!haveField)
                {
                    superOf(t, -1);

                    if(isNull(t, -1))
                        return 0;

                    setUpval(t, 0);
                    pushInt(t, 0);
                    setUpval(t, 1);
                    pop(t);

                    // try again
                    continue;
                }

                // See if we've already seen this field
                getUpval(t, 2);
                pushStringObj(t, *key);

                if(opin(t, -1, -2))
                {
                    pushInt(t, index);
                    setUpval(t, 1);
                    pop(t, 3);

                    // We have, try again
                    continue;
                }

                // Mark the field as seen
                pushBool(t, true);
                idxa(t, -3);
                pop(t, 3);

                break;
            }

            pushInt(t, index);
            setUpval(t, 1);

            pushStringObj(t, *key);
            push(t, *value);
            
            if(i is null)
                pushClass(t, c);
            else
                pushInstance(t, i);

            return 3;
        }

        checkAnyParam(t, 1);
        
        if(!isClass(t, 1) && !isInstance(t, 1))
            paramTypeError(t, 1, "class|instance");

        dup(t, 1);
        pushInt(t, 0);
        newTable(t);
        newFunction(t, &iter, "allFieldsOfIter", 3);
        return 1;
    }

    uword hasField(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        auto n = checkStringParam(t, 2);
        pushBool(t, .hasField(t, 1, n));
        return 1;
    }

    uword hasMethod(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        auto n = checkStringParam(t, 2);
        pushBool(t, .hasMethod(t, 1, n));
        return 1;
    }

    uword findField(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        
        if(!isInstance(t, 1) && !isClass(t, 1))
            paramTypeError(t, 1, "class|instance");

        checkStringParam(t, 2);

        while(!isNull(t, 1))
        {
            auto fields = .fieldsOf(t, 1);

            if(opin(t, 2, fields))
            {
                dup(t, 1);
                return 1;
            }

            superOf(t, 1);
            swap(t, 1);
            pop(t, 2);
        }

        return 0;
    }

    uword rawSetField(MDThread* t, uword numParams)
    {
        checkInstParam(t, 1);
        checkStringParam(t, 2);
        checkAnyParam(t, 3);
        dup(t, 2);
        dup(t, 3);
        fielda(t, 1, true);
        return 0;
    }

    uword rawGetField(MDThread* t, uword numParams)
    {
        checkInstParam(t, 1);
        checkStringParam(t, 2);
        dup(t, 2);
        field(t, 1, true);
        return 1;
    }

    uword attrs(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        checkParam(t, 2, MDValue.Type.Table);
        dup(t, 2);
        setAttributes(t, 1);
        dup(t, 1);
        return 1;
    }

    uword hasAttributes(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        pushBool(t, .hasAttributes(t, 1));
        return 1;
    }

    uword attributesOf(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        getAttributes(t, 1);
        return 1;
    }

    uword isParam(MDValue.Type Type)(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        pushBool(t, type(t, 1) == Type);
        return 1;
    }

    // ===================================================================================================================================
    // Conversions

    uword toString(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);

        if(isInt(t, 1))
        {
            char[1] style = "d";

            if(numParams > 1)
                style[0] = getChar(t, 2);

            char[80] buffer = void;
            pushString(t, safeCode(t, Integer.format(buffer, getInt(t, 1), style)));
        }
        else
            pushToString(t, 1);

        return 1;
    }

    uword rawToString(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        pushToString(t, 1, true);
        return 1;
    }

    uword toBool(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);
        pushBool(t, isTrue(t, 1));
        return 1;
    }

    uword toInt(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);

        switch(type(t, 1))
        {
            case MDValue.Type.Bool:   pushInt(t, cast(mdint)getBool(t, 1)); break;
            case MDValue.Type.Int:    dup(t, 1); break;
            case MDValue.Type.Float:  pushInt(t, cast(mdint)getFloat(t, 1)); break;
            case MDValue.Type.Char:   pushInt(t, cast(mdint)getChar(t, 1)); break;
            case MDValue.Type.String: pushInt(t, safeCode(t, cast(mdint)Integer.toLong(getString(t, 1), 10))); break;

            default:
                pushTypeString(t, 1);
                throwException(t, "Cannot convert type '{}' to int", getString(t, -1));
        }

        return 1;
    }

    uword toFloat(MDThread* t, uword numParams)
    {
        checkAnyParam(t, 1);

        switch(type(t, 1))
        {
            case MDValue.Type.Bool: pushFloat(t, cast(mdfloat)getBool(t, 1)); break;
            case MDValue.Type.Int: pushFloat(t, cast(mdfloat)getInt(t, 1)); break;
            case MDValue.Type.Float: dup(t, 1); break;
            case MDValue.Type.Char: pushFloat(t, cast(mdfloat)getChar(t, 1)); break;
            case MDValue.Type.String: pushFloat(t, safeCode(t, cast(mdfloat)Float.toFloat(getString(t, 1)))); break;

            default:
                pushTypeString(t, 1);
                throwException(t, "Cannot convert type '{}' to float", getString(t, -1));
        }

        return 1;
    }

    uword toChar(MDThread* t, uword numParams)
    {
        pushChar(t, cast(dchar)checkIntParam(t, 1));
        return 1;
    }

    uword format(MDThread* t, uword numParams)
    {
        auto buf = StrBuffer(t);
        formatImpl(t, numParams, &buf.sink);
        buf.finish();
        return 1;
    }

    // ===================================================================================================================================
    // Console IO

    uword write(MDThread* t, uword numParams)
    {
        for(uword i = 1; i <= numParams; i++)
        {
            pushToString(t, i);
            Stdout(getString(t, -1));
        }

        Stdout.flush;
        return 0;
    }

    uword writeln(MDThread* t, uword numParams)
    {
        for(uword i = 1; i <= numParams; i++)
        {
            pushToString(t, i);
            Stdout(getString(t, -1));
        }

        Stdout.newline;
        return 0;
    }

    uword writef(MDThread* t, uword numParams)
    {
        uint sink(char[] data