Pasted

 
include "string";
 
/*
extern func println( string str );
template< typename T > array
{
    T* m_data;
    int m_size;
    int m_mem;
    
    operator [] ( int index ) : T
    {
        if( index < 0 || index >= m_size )
        {
            WARNING( "array index out of bounds" );
            return T();
        }
        return m_data[ index ];
    }
};
func main( array<string> args )
{
    for( i = 0; i < args.size; ++i )
        println( args[ i ] );
    println( "Hello, world! (" $ args.size $ ")" );
}
func _test()
{
    main( [ "array", "data", "test" ] );
}
*/
 
/*
PROBLEMS
 
> efficient local variable encoding
- all local variables have a scope but name should not be duplicated or resolved, we can use an offset table at most (padding could be arch-dependent)
- { type = "scope", locals = [{ name = "one", type = "string" }, { name = "b", type = "int" }], code = [..] },
- locals are added to stack and accessed by their index
 
 
IDEAS
 
> WARNING arguments:
- string specific - the case-specific error part ("15 outside [0;7]")
- optional string generic - the error group part ("array index out of bounds")
- optional string category - the error category path ("RangeError/OutOfBounds")
 
*/
 
global AST =
{
    "string*" = { type = "pointer", datatype = "string" },
    "array<string>" =
    {
        type = "object",
        classname = "array",
        fullname = "array<string>",
        members =
        [
            { name = "m_data", type = "string*" },
            { name = "m_size", type = "int" },
            { name = "m_mem", type = "int" },
        ],
        static = [],
    },
    "array<string>:[](int)" =
    {
        type = "function",
        retntype = "string",
        params =
        [
            { name = "index", type = "int" },
        ],
        locals = [],
        code =
        [
            { type = "if",
                test = { type = "or",
                    lft = { type = "lt", datatype = "int", lft = { type = "local", off = 0 }, rgt = { type = "data", datatype = "int", data = 0 } },
                    rgt = { type = "gte", datatype = "int", lft = { type = "local", off = 0 }, rgt = { type = "getmember", name = "m_size" } },
                },
                locals_ontrue = [],
                locals_onfalse = [],
                ontrue =
                [
                    { type = "fcall", func = "WARNING", ctx = null, args = [{ type = "data", datatype = "string", data = "array index out of bounds" }] },
                    { type = "return", arg = { type = "data", datatype = "string", data = "" } },
                ],
                onfalse = [],
            },
            { type = "return", arg = { type = "getindex", object = { type = "getmember", name = "m_data" }, index = { type = "local", off = 0 } } },
        ],
    },
    "array<string>:size.get" = { type = "getter", retntype = "int", source = "m_size" },
    "array<string>:clear()" =
    {
        type = "function",
        retntype = "void",
        params = [],
        locals = [],
        code =
        [
            { type = "fcall", func = "array<string>:resize(int)", ctx = null, args = [{ type = "data", datatype = "int", data = 0 }] },
        ],
    },
    "println(string)" = { type = "external", func = println, retntype = "void", params = [{ name = "str", type = "string" }] },
    "main(array<string>)" =
    {
        type = "function",
        retntype = "void",
        params =
        [
            { name = "args", type = "array<string>" },
        ],
        locals = [],
        code =
        [
            { type = "for",
                init = { type = "setlocal", datatype = "int", off = 1, value = { type = "data", datatype = "int", data = 0 } },
                test = { type = "lt", datatype = "int",
                    lft = { type = "local", off = 1 },
                    rgt = { type = "getprop", object = { type = "local", off = 0 }, property = { type = "data", datatype = "string", data = "size" } }
                },
                next = { type = "setlocal", datatype = "int", off = 1, value = { type = "add", datatype = "int",
                    lft = { type = "local", off = 1 },
                    rgt = { type = "data", datatype = "int", data = 1 } }
                },
                locals = [{ name = "i", type = "int" }],
                body =
                [
                    { type = "fcall", func = "println(string)", ctx = null, args = [{ type = "getindex", object = { type = "local", off = 0 }, index = { type = "local", off = 1 } }] },
                ]
            },
            { type = "fcall", func = "println(string)", ctx = null, args =
            [
                { type = "concat", args =
                [
                    { type = "data", datatype = "string", data = "Hello, world! (" },
                    { type = "convert", datatype = "string", source = { type = "getprop", object = { type = "local", off = 0 }, property = { type = "data", datatype = "string", data = "size" } } },
                    { type = "data", datatype = "string", data = ")" },
                ]},
            ]},
        ],
    },
    "_test()" =
    {
        type = "function",
        retntype = "void",
        params = [],
        locals = [],
        code =
        [
            { type = "fcall", func = "main(array<string>)", ctx = null, args =
            [
                { type = "data", datatype = "array<string>", data =
                {
                    m_data = 
                    [
                        { type = "string", data = "array" },
                        { type = "string", data = "data" },
                        { type = "string", data = "test" }
                    ],
                    m_size = { type = "int", data = 3 },
                    m_mem = { type = "int", data = 3 },
                }},
            ]},
        ],
    },
};
 
 
 
function resolve_type( typename )
{
    tydata = @AST[ typename ];
    if( tydata )
        return tydata;
    if( typename != "int" && typename != "string" )
        return ERROR( "no such type: " $ typename );
    return { type = typename };
}
 
function value_is_nonzero( value )
{
    if( !value )
        return false;
    if( value.type == "bool" )
        return value.data;
    if( value.type == "int" )
        return value.data != 0;
    if( value.type == "string" )
        return value.data.size != 0;
    return true;
}
 
global CALL_STACK = [];
 
function do__push_locals( locals )
{
    outlocals = CALL_STACK.last.locals;
    foreach( local : locals )
        outlocals.push({ name = local.name, type = local.type, data = null });
}
 
function do__pop_locals( locals )
{
    for( i = 0; i < locals.size; ++i )
        CALL_STACK.last.locals.pop();
}
 
function do_fcall( func, ctx, args )
{
    fndata = @AST[ func ];
    if( !fndata )
        return WARNING( "function was not found: " $ func );
    
    if( fndata.type == "external" )
    {
        argsdata = [];
        foreach( carg : args )
            argsdata.push( carg.data );
        fndata.func.apply( ctx, argsdata );
    }
    else
    {
        CALL_STACK.push
        ({
            name = func,
            func = fndata,
            ctx = ctx,
            locals = [],
            retn = false,
        });
        do__push_locals( fndata.params );
        foreach( i, arg : args )
            CALL_STACK.last.locals[ i ].data = arg;
        do__push_locals( fndata.locals );
        foreach( line : fndata.code )
        {
            do_item( line );
        }
        return CALL_STACK.pop().retn;
    }
}
 
function vm_is_a( type, what )
{
    return type == what;
}
 
function do_concat( args )
{
    out = "";
    foreach( arg : args )
    {
        arg = do_item( arg );
        if( !vm_is_a( arg.type, "string" ) )
            ERROR( "CONCAT argument " $ arg $ " is not a string" );
        out $= arg.data;
    }
    return { type = "string", data = out };
}
 
function do_getprop( obj, prop )
{
    if( prop.type != "string" )
        return WARNING( "property has invalid type: " $ prop );
    
    typeinfo = resolve_type( obj.type );
    key = typeinfo.fullname $ ":" $ prop.data $ ".get";
    fndata = @AST[ key ];
    if( fndata )
    {
        if( fndata.type == "getter" )
            return obj.data[ fndata.source ];
        if( fndata.type == "function" )
            return do_fcall( key, obj, [] );
    }
    foreach( name, val : obj.data )
    {
        if( name == prop.data )
            return val;
    }
    
    WARNING( "unknown property " $ prop $ " for object " $ obj );
}
 
function do_getindex( obj, idx )
{
    // special case: pointers
    if( is_array( obj ) )
    {
        return obj[ idx.data ];
    }
    
    typeinfo = resolve_type( obj.type );
    key = typeinfo.fullname $ ":[](" $ idx.type $ ")";
    fndata = @AST[ key ];
    if( fndata )
    {
        if( fndata.type == "function" )
            return do_fcall( key, obj, [ idx ] );
    }
    
    WARNING( "unknown index " $ idx $ " for object " $ obj );
}
 
function do_convert( item, typeto )
{
    if( item.type == typeto )
        return item;
    
    if( typeto == "string" )
    {
        return { type = "string", data = tostring( item.data ) };
    }
    
    ERROR( "don't know how to convert from " $ item.type $ " to " $ typeto );
}
 
function do_add( lft, rgt )
{
    lft = do_item( lft );
    rgt = do_item( rgt );
    if( lft.type == "int" && rgt.type == "int" )
        return { type = "int", data = lft.data + rgt.data };
    ERROR( "don't know how to do 'add' on this type" );
}
 
function do_lt( lft, rgt )
{
    lft = do_item( lft );
    rgt = do_item( rgt );
    if( lft.type == "int" && rgt.type == "int" )
        return { type = "bool", data = lft.data < rgt.data };
    ERROR( "don't know how to do 'lt' on this type" );
}
 
function do_gte( lft, rgt )
{
    lft = do_item( lft );
    rgt = do_item( rgt );
    if( lft.type == "int" && rgt.type == "int" )
        return { type = "bool", data = lft.data >= rgt.data };
    ERROR( "don't know how to do 'gte' on this type" );
}
 
function do_or( lft, rgt )
{
    if( value_is_nonzero( do_item( lft ) ) )
        return true;
    return value_is_nonzero( do_item( rgt ) );
}
 
function do_item( item )
{
    if( !item )
        return;
    
    if( CALL_STACK.last.retn )
        return;
    
    println( string_repeat( " ", 40 ) $ "doing " $ item.type $ " in " $ CALL_STACK.last.name );
    if( item.type == "data" )
        return { type = item.datatype, data = item.data };
    if( item.type == "local" )
    {
        local = CALL_STACK.last.locals[ item.off ];
        println( string_repeat( " ", 30 ) $ "reading local " $ local.name $ "@" $ item.off $ " = " $ local.data );
        return local.data;
    }
    if( item.type == "setlocal" )
    {
        local = CALL_STACK.last.locals[ item.off ];
        value = do_item( item.value );
        println( string_repeat( " ", 30 ) $ "writing local " $ local.name $ "@" $ item.off $ " = " $ value );
        return local.data = value;
    }
    if( item.type == "convert" )
    {
        return do_convert( do_item( item.source ), item.datatype );
    }
    if( item.type == "if" )
    {
        if( value_is_nonzero( do_item( item.test ) ) )
        {
            do__push_locals( item.locals_ontrue );
            foreach( line : item.ontrue )
                do_item( line );
            do__pop_locals( item.locals_ontrue );
        }
        else
        {
            do__push_locals( item.locals_onfalse );
            foreach( line : item.onfalse )
                do_item( line );
            do__pop_locals( item.locals_onfalse );
        }
        return;
    }
    if( item.type == "for" )
    {
        do__push_locals( item.locals );
        do_item( item.init );
        while( value_is_nonzero( do_item( item.test ) ) )
        {
            foreach( line : item.body )
                do_item( line );
            do_item( item.next );
        }
        do__pop_locals( item.locals );
        return;
    }
    if( item.type == "fcall" )
    {
        args = [];
        foreach( arg : item.args )
            args.push( do_item( arg ) );
        return do_fcall( item.func, do_item( item.ctx ), args );
    }
    if( item.type == "return" )
    {
        CALL_STACK.last.retn = if( @item.arg, do_item( item.arg ), true );
        return;
    }
    if( item.type == "concat" )
        return do_concat( item.args );
    
    if( item.type == "getprop" ) return do_getprop( do_item( item.object ), do_item( item.property ) );
    if( item.type == "getmember" ) return do_getprop( CALL_STACK.last.ctx, { type = "string", data = item.name } );
    if( item.type == "getindex" ) return do_getindex( do_item( item.object ), do_item( item.index ) );
    
    if( item.type == "add" ) return do_add( item.lft, item.rgt );
    
    if( item.type == "lt" ) return do_lt( item.lft, item.rgt );
    if( item.type == "gte" ) return do_gte( item.lft, item.rgt );
    
    if( item.type == "or" ) return do_or( item.lft, item.rgt );
    
    ERROR( "cannot do action " $ item.type );
}
 
 
do_fcall( "_test()", null, [] );