root/attic/testscript.txt

/*
OK.  An identifier can refer to either a local variable or to a variable in the context ("this").  So:

local function func()
{

}
*/

// All the code that follows is run as a function - it is compiled, and then run.  Each declaration of
// a function, variable, or class, is actually run as a statement, and inserts a symbol into some namespace
// (which is just a table).  "local" declarations are local to the function - that is, when the function
// returns, the variable will be lost.  These would be like "private" module declarations in D.  "global"
// declarations are inserted into the global namespace, and will be accessible to all code after this
// function ends; this is usually bad practice, so good practice is to make a global namespace table (the
// "module") and then insert any symbols you want to export into that table.

// We will be using "test" as our module name.  Any symbols we want to be exported go into this table.
global test = { };

// "import" is just a function that checks to see if the given module is loaded, and attempts to load
// it if it isn't.
import("io");
import("string");

// Create a local function called "fork".
local function fork(x, y)
{
    // This is how you do a "default parameter"
    if(y is null)
        y = 10;

    io.writefln("fork: ", x + y);
}

// Create a local class called "A".  A class is a special kind of table.
local class A
{
    // Some member variables.  We don't declare these as "local" or "global" because
    // a class declaration is pretty much a table declaration, so these are just
    // fields in a table.
    mValue = 0;
    mName = "";

    // This is the constructor; it is otherwise a normal function, but is only
    // called when the class is instantiated.
    function constructor()
    {
        io.writefln("A ctor");
    }

    // You can make "properties" using the opIndex and opIndexAssign operators.
    // This is because, as in Lua or Squirrel, the syntax 'a.b' is equivalent to 'a["b"]'.
    function opIndex(index)
    {
        switch(index)
        {
            case "name":
                // Notice the explicit use of "this".  This is because there are four places
                // a variable can live: locally (in the function); in an enclosing function
                // (called an "upvalue"); globally; or in the function's context, or "this",
                // table.  An identifier on its own can only refer to a local variable or
                // upvalue; context variables are accessed through "this"; and globals are
                // accessed as in D, with the global scope operator (".ident").
                return this.mName;

            case "value":
                return this.mValue;
                
            default:
                throw("Property 'A.'" ~ index.toString() ~ "' does not have a getter");
        }
    }

    // The setter function.
    function opIndexAssign(value, index)
    {
        switch(index)
        {
            case "name":
                this.mName = value.toString();
                return;
                
            default:
                throw("Property 'A." ~ index.toString() ~ "' does not have a setter");
        }
    }

    // A plain old method.  Again, notice we're using "this" to access the member variable.
    function incValue()
    {
        ++this.mValue;
    }
}

// We can even derive classes.
local class B : A
{
    function constructor()
    {
        io.writefln("B ctor");
        this.super.constructor();
    }
}

// Remember the "module table" 'test' that we created before?  Here's where we're exporting
// everything.

test =
{
    fork = fork
    A = A
    B = B
}

// There is no "main()", since the entire "module" is run as a function.
fork(5);
fork(8, 3);

local a = A();
a.name = "Hello";
io.writefln("a is called \"", a.name, "\"");
a.name = 4;
io.writefln("a is now called \"", a.name, "\"");
io.writefln("a's value is ", a.value);
a.incValue();
io.writefln("a's value is now ", a.value);


/*
Types

--value--
null
bool
int
float

--ref--
string
table
array
closure
class
classinst
userdata
*/

/*
function name:
    locals
    constants
    enclosed functions
    upvalues
    case tables
*/

// "push function() {"

global test = { };
/*
new table into temp reg;
put temp reg into global "test";
*/

import("io");
/*
get global "import" into temp reg;
push const "io";
call temp reg;
*/

import("string");
/*
get global "import" into temp reg;
push const "string";
call temp reg;
*/

local f = null;
// allocate register as "f";

class Foo
{
    def fork()
    {
        f = new Foo();
    }
    /*
    Foo.fork:

    */
}
/*
allocate register as "Foo";

*/

function caller(f)
{
    f();
}

function foo()
{
    local x = 
    function bar()
    {
        ::print("hi!");
    }


}

test.Foo = Foo;

class Test
{
    this()
    {
        io.writefln("hi");
    }

    this(int x)
    {
        writefln("hey: ", x);
    }

    ~this()
    {
        writefln("bye");
    }

    def int mX;
    def int mY;

    def void fork()
    {
        writefln(this.mX + this.mY);
    }

    namespace x
    {
        def int opSet(int val)
        {
            return mX = val;
        }

        def int opSet(char[] val)
        {
            return mX = string.toInt(val);
        }

        def int opGet()
        {
            return mX;
        }
    }
}

def void foo(int x, int y)
{
    def float z = x + y;

    io.writefln("z = ", z);
}

class A
{

}

class B : A
{
    def int mX = 3;

    def void method(int x)
    {
        io.writefln("mX = ", mX, " x = ", x);
    }
}

def void knife()
{

}

def int function(int) foo(int n)
{
    return function int(int i)
    {
        n += i;
        return n;
    };
}

def void function() fork(int x, int y = 10)
{
    def int z = x + y;

    def void enclosed()
    {
        writefln(z);
    }

    enclosed();

    def Test t = new Test();
    def B b = new B();
    def A a = b;

    if(cast(B)a)
        writefln("it's a B");

    b.method(4);

    def void function(int) f = b.method;
    def void function() g = enclosed;
    def void function() h = knife;

    delete b;

    // Function literal is instantiated ("closed") automatically upon being returned
    return enclosed;
}

def void myWritefln(vararg args)
{
    io.writef("my writefln: ");
    io.writefln(args);
}

// Making a vararg function
def void testVararg(vararg args)
{
    io.writefln("Got ", args.length, " arguments");

    for(def int i = 0; i < args.length; ++i)
    {
        io.writef("arg[", i, "] = ");

        switch(args.type(i))
        {
            case "int":
                io.writefln(args.asInt(i));
                break;

            case "float":
                io.writefln(args.asFloat(i));
                break;

            case "char[]":
                io.writefln(`"`, args.asString(i), `"`);
                break;

            default:
                io.writefln("something scary");
                break;
        }
    }
}

// Get three instances of the function returned by fork (which has a default argument).
def void function() n = fork(5);
def void function() m = fork(10);
def void function() l = fork(3, 7);

// Call those three instances.  Notice that they all print different things, as their upvalues
// all have different values.
n();
m();
l();

// Try out the variadic function.
testVararg(5, 3.3, "hi");
writefln();
testVararg();
writefln();

// Calling a function indirectly.
def void function(vararg) blah = testVararg;
blah(4, 5, 6);

def Test t = new Test();
t.fork();
def int[] x = new int[](4);

if(4 < 5)
    writefln("hi");
else
    writefln("bye");

// }