Beispiel #1
0
 protected  List<Instruction> GetInstructions(string assemblerCode)
 {
     var app = new Application("getInstructions");
     var opt = new LoaderOptions(engine, app);
     opt.UseIndicesLocally = false;
     var ldr = new Loader(opt);
     ldr.LoadFromString("function MyAssemblerFunction does asm {" + assemblerCode + "\n}");
     if (ldr.ErrorCount != 0)
     {
         Console.WriteLine("--------------- Assembler Code --------------------");
         Console.WriteLine(assemblerCode);
         Console.WriteLine("---------------- End Asm Code ---------------------");
         foreach (var error in ldr.Errors)
             Assert.Fail(string.Format("Error in the expected assembler code: {0}", error));
     }
     return app.Functions["MyAssemblerFunction"].Code;
 }
Beispiel #2
0
        public static PValue RunStatically(StackContext sctx, PValue[] args)
        {
            if (sctx == null)
                throw new ArgumentNullException("sctx");
            if (args == null)
                args = new PValue[] {};

            var eng = sctx.ParentEngine;
            foreach (var arg in args)
            {
                var path = arg.CallToString(sctx);
                var ldrOptions = new LoaderOptions(sctx.ParentEngine, sctx.ParentApplication);
                ldrOptions.ReconstructSymbols = false;
                var ldr = sctx as Loader ?? new Loader(ldrOptions);
                var asmFile = ldr.ApplyLoadPaths(path);
                if (asmFile == null)
                    throw new FileNotFoundException("Prexonite can't load assembly located in " +
                        path);

                eng.RegisterAssembly(Assembly.LoadFile(asmFile.FullName));
            }

            return PType.Null.CreatePValue();
        }
Beispiel #3
0
        public void AsmIdArgInstructions()
        {
            const string input1 =
                @"
function func1 does asm
{
    newobj.1    ""Object(\""System.Text.StringBuilder\"")""
    newtype.1   ""Object""
    get.3       ToString
    set.2       __\defaultIndex
    new.1       ""Object(\""System.DateTime\"")""
    sget.10     ""Object(\""System.Console\"")::WriteLine""
    sset.1      ""Object(\""System.Console\"")::ForegroundColor""
    indloc.2    aFunction
    indglob.3   anotherFunction
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");

            var code = target.Functions["func1"].Code;
            var i = 0;

            Assert.AreEqual(OpCode.newobj, code[i].OpCode);
            Assert.AreEqual("Object(\"System.Text.StringBuilder\")", code[i].Id);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.newtype, code[i].OpCode);
            Assert.AreEqual("Object", code[i].Id);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.get, code[i].OpCode);
            Assert.AreEqual("ToString", code[i].Id);
            Assert.AreEqual(3, code[i++].Arguments);

            Assert.AreEqual(OpCode.set, code[i].OpCode);
            Assert.AreEqual("__\\defaultIndex", code[i].Id);
            Assert.AreEqual(2, code[i++].Arguments);

            Assert.AreEqual(OpCode.newobj, code[i].OpCode);
            Assert.AreEqual("Object(\"System.DateTime\")", code[i].Id);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.sget, code[i].OpCode);
            Assert.AreEqual("Object(\"System.Console\")::WriteLine", code[i].Id);
            Assert.AreEqual(10, code[i++].Arguments);

            Assert.AreEqual(OpCode.sset, code[i].OpCode);
            Assert.AreEqual("Object(\"System.Console\")::ForegroundColor", code[i].Id);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.indloc, code[i].OpCode);
            Assert.AreEqual("aFunction", code[i].Id);
            Assert.AreEqual(2, code[i++].Arguments);

            Assert.AreEqual(OpCode.indglob, code[i].OpCode);
            Assert.AreEqual("anotherFunction", code[i].Id);
            Assert.AreEqual(3, code[i++].Arguments);
        }
Beispiel #4
0
        public void AsmSpecialInstructions()
        {
            const string input1 =
                @"
function func1(param1)  [ key value; ] does asm
{
    rot.2,3
    swap
    ldc.real    -2.53e-3
    ldc.real    2.5
    ldc.bool    false
    ldc.bool    TrUe
    indarg.3
    inda.0
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");

            var code = target.Functions["func1"].Code;
            var i = 0;

            Assert.AreEqual(OpCode.rot, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(3, (int) code[i++].GenericArgument);

            Assert.AreEqual(OpCode.rot, code[i].OpCode);
            Assert.AreEqual(1, code[i].Arguments);
            Assert.AreEqual(2, (int) code[i++].GenericArgument);

            Assert.AreEqual(OpCode.ldc_real, code[i].OpCode);
            Assert.AreEqual(-2.53e-3, (double) code[i++].GenericArgument);

            Assert.AreEqual(OpCode.ldc_real, code[i].OpCode);
            Assert.AreEqual(2.5, (double) code[i++].GenericArgument);

            Assert.AreEqual(OpCode.ldc_bool, code[i].OpCode);
            Assert.AreEqual(0, code[i++].Arguments);

            Assert.AreEqual(OpCode.ldc_bool, code[i].OpCode);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.indarg, code[i].OpCode);
            Assert.AreEqual(3, code[i++].Arguments);

            Assert.AreEqual(OpCode.indarg, code[i].OpCode);
            Assert.AreEqual(0, code[i++].Arguments);
        }
Beispiel #5
0
        public void AsmIdInstructions()
        {
            const string input1 =
                @"
var glob1;
function func1 does asm
{
    var    loc1
    ldc.string      ""Hello World""
    ldr.func        func1
    ldr.glob        glob1
    ldr.loc         loc1
    ldr.type        Int
    ldloc           loc1
    stloc           loc1
    ldglob          glob1
    stglob          glob1
    check.const     Int
    cast.const      Int
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilation.");

            var code = target.Functions["func1"].Code;
            var i = 0;

            Assert.AreEqual(OpCode.ldc_string, code[i].OpCode);
            Assert.AreEqual("Hello World", code[i++].Id);

            Assert.AreEqual(OpCode.ldr_func, code[i].OpCode);
            Assert.AreEqual("func1", code[i++].Id);

            Assert.AreEqual(OpCode.ldr_glob, code[i].OpCode);
            Assert.AreEqual("glob1", code[i++].Id);

            Assert.AreEqual(OpCode.ldr_loc, code[i].OpCode);
            Assert.AreEqual("loc1", code[i++].Id);

            Assert.AreEqual(OpCode.ldr_type, code[i].OpCode);
            Assert.AreEqual("Int", code[i++].Id);

            Assert.AreEqual(OpCode.ldloc, code[i].OpCode);
            Assert.AreEqual("loc1", code[i++].Id);

            Assert.AreEqual(OpCode.stloc, code[i].OpCode);
            Assert.AreEqual("loc1", code[i++].Id);

            Assert.AreEqual(OpCode.ldglob, code[i].OpCode);
            Assert.AreEqual("glob1", code[i++].Id);

            Assert.AreEqual(OpCode.stglob, code[i].OpCode);
            Assert.AreEqual("glob1", code[i++].Id);

            Assert.AreEqual(OpCode.check_const, code[i].OpCode);
            Assert.AreEqual("Int", code[i++].Id);

            Assert.AreEqual(OpCode.cast_const, code[i].OpCode);
            Assert.AreEqual("Int", code[i++].Id);
        }
Beispiel #6
0
        public void AsmNullInstructions()
        {
            const string input1 =
                @"
function func1() does asm
{
    //Instructions in the null group
    nop             //0
    ldc.null        //1
    nop             //2
    nop             //3
    neg             //4
    not             //5
    add             //6
    sub             //7
    mul             //8
    div             //9
    mod             //10
    pow             //11
    ceq             //12
    cne             //13
    cgt             //14
    cge             //15
    clt             //16
    cle             //17
    or              //18
    and             //19
    xor             //20
    check.arg       //21
    cast . arg      //22
    ldr.eng         //23
    ldr. app        //24
    ret.exit        //25
    ret.break       //26
    ret.continue    //27
    ret.set         //28
    ret.value       //29

    //Aliases
    continue        //30
    break           //31
    ret             //32
    exit            //33
}
";

            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            var code = target.Functions["func1"].Code;
            var i = 0;
            Assert.AreEqual(OpCode.nop, code[i++].OpCode);
            Assert.AreEqual(OpCode.ldc_null, code[i++].OpCode);
            Assert.AreEqual(OpCode.nop, code[i++].OpCode);
            Assert.AreEqual(OpCode.nop, code[i++].OpCode);
            //operator aliases
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(1, code[i].Arguments);
            Assert.AreEqual(UnaryNegation.DefaultAlias, code[i++].Id);
            Assert.AreEqual(1, code[i].Arguments);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(LogicalNot.DefaultAlias, code[i++].Id);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(Addition.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Subtraction.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Multiplication.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Division.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Modulus.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Power.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Equality.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(Inequality.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(GreaterThan.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(GreaterThanOrEqual.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(LessThan.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(LessThanOrEqual.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(BitwiseOr.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(BitwiseAnd.DefaultAlias, code[i++].Id);
            Assert.AreEqual(OpCode.cmd, code[i].OpCode);
            Assert.AreEqual(2, code[i].Arguments);
            Assert.AreEqual(ExclusiveOr.DefaultAlias, code[i++].Id);
            //other nullary instructions
            Assert.AreEqual(OpCode.check_arg, code[i++].OpCode);
            Assert.AreEqual(OpCode.cast_arg, code[i++].OpCode);
            Assert.AreEqual(OpCode.ldr_eng, code[i++].OpCode);
            Assert.AreEqual(OpCode.ldr_app, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_exit, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_break, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_continue, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_set, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_value, code[i++].OpCode);

            //Aliases
            Assert.AreEqual(OpCode.ret_continue, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_break, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_value, code[i++].OpCode);
            Assert.AreEqual(OpCode.ret_exit, code[i++].OpCode);
        }
Beispiel #7
0
        public void AsmLocalVariableDeclaration()
        {
            const string input1 = @"
function func1() does asm
{
    var loc1
    ref loc2
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            Assert.IsTrue(target.Functions["func1"].Variables.Contains("loc1"));
            Assert.AreEqual(
                SymbolInterpretations.LocalObjectVariable,
                LookupSymbolEntry(ldr.FunctionTargets["func1"].Symbols, "loc1").Interpretation);

            Assert.IsTrue(target.Functions["func1"].Variables.Contains("loc2"));
            Assert.AreEqual(
                SymbolInterpretations.LocalReferenceVariable,
                LookupSymbolEntry(ldr.FunctionTargets["func1"].Symbols, "loc2").Interpretation);
        }
Beispiel #8
0
        public void VariableDeclarations()
        {
            const string input1 =
                @"
function func0
{
    var obj0;
    var obj1;
    var obj2;

    ref func1;
    ref ifunc0;
    ref cor0;

    declare var gobj0;    
    declare var gobj1;
    
    static sobj0;
    static sobj1;
}
";
            var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            foreach (var message in ldr.Errors)
            {
                Console.WriteLine(message);
            }
            Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");

            // We allow up to two instructions (`return sobj1`) to accomodate the
            //  relaxed treatment of variable declarations in Prexonite 2
            Assert.That(ldr.FunctionTargets["func0"].Code.Count, Is.LessThanOrEqualTo(2));

            CompilerTarget tar = ldr.FunctionTargets["func0"];

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj0", null),
                LookupSymbolEntry(tar.Symbols, "obj0"));
            Assert.IsTrue(tar.Function.Variables.Contains("obj0"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj1", null),
                LookupSymbolEntry(tar.Symbols, "obj1"));
            Assert.IsTrue(tar.Function.Variables.Contains("obj1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalObjectVariable, "obj2", null),
                LookupSymbolEntry(tar.Symbols, "obj2"));
            Assert.IsTrue(tar.Function.Variables.Contains("obj2"));

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "func1", null),
                LookupSymbolEntry(tar.Symbols, "func1"));
            Assert.IsTrue(tar.Function.Variables.Contains("func1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "ifunc0", null),
                LookupSymbolEntry(tar.Symbols, "ifunc0"));
            Assert.IsTrue(tar.Function.Variables.Contains("ifunc0"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.LocalReferenceVariable, "cor0", null),
                LookupSymbolEntry(tar.Symbols, "cor0"));
            Assert.IsTrue(tar.Function.Variables.Contains("cor0"));

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "gobj0", target.Module.Name),
                LookupSymbolEntry(tar.Symbols, "gobj0"));
            Assert.IsFalse(
                tar.Function.Variables.Contains("gobj0"),
                "\"declare var <id>;\" only declares a global variable.");
            Assert.IsFalse(
                ldr.Options.TargetApplication.Variables.ContainsKey("gobj0"),
                "\"global <id>;\" only declares a global variable.");
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "gobj1", target.Module.Name),
                LookupSymbolEntry(tar.Symbols, "gobj1"));
            Assert.IsFalse(
                tar.Function.Variables.Contains("gobj1"),
                "\"declare var <id>;\" only declares a global variable.");
            Assert.IsFalse(
                ldr.Options.TargetApplication.Variables.ContainsKey("gobj1"),
                "\"declare var <id>;\" only declares a global variable.");

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "func0\\static\\sobj0", target.Module.Name),
                LookupSymbolEntry(tar.Symbols, "sobj0"));
            Assert.IsTrue(
                ldr.Options.TargetApplication.Variables.ContainsKey("func0\\static\\sobj0"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "func0\\static\\sobj1", target.Module.Name),
                LookupSymbolEntry(tar.Symbols, "sobj1"));
            Assert.IsTrue(
                ldr.Options.TargetApplication.Variables.ContainsKey("func0\\static\\sobj1"));
        }
Beispiel #9
0
        public void DefineGlobal()
        {
            //First declare the variables

            const string input1 =
                "declare var name1; " +
                    "declare ref name2; " +
                        "declare var value;";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(
                0, ldr.ErrorCount, "The compiler reported errors in the first chunk of code.");
            var symbols = ldr.TopLevelSymbols;

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name1", target.Module.Name),
                LookupSymbolEntry(symbols, "name1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
                LookupSymbolEntry(symbols, "name2"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "value", target.Module.Name),
                LookupSymbolEntry(symbols, "value"));

            //Then define them
            const string input2 =
                "var name1; " +
                    "ref name2 [ Description NotUseful; ]; " +
                        "var name3;";

            ldr.LoadFromString(input2);
            Assert.AreEqual(
                0, ldr.ErrorCount, "The compiler reported errors in the second chunk of code.");
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name1", target.Module.Name),
                LookupSymbolEntry(symbols, "name1"));
            Assert.IsNotNull(target.Variables["name1"]);
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
                LookupSymbolEntry(symbols, "name2"));
            Assert.IsNotNull(target.Variables["name2"]);
            Assert.AreEqual("NotUseful", target.Variables["name2"].Meta["description"].Text);
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name3", target.Module.Name),
                LookupSymbolEntry(symbols, "name3"));
            Assert.IsNotNull(target.Variables["name3"]);
        }
Beispiel #10
0
        public void Redeclare()
        {
            const string input =
                "declare function name1; " +
                    "declare var name2; " +
                        "declare ref name1, name2; " +
                            "declare function name1;";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input);
            Assert.AreEqual(0, ldr.ErrorCount);
            var symbols = ldr.TopLevelSymbols;

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));
            Assert.AreNotEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "name2", target.Module.Name),
                LookupSymbolEntry(symbols, "name2"));
            Assert.AreNotEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name1", target.Module.Name),
                LookupSymbolEntry(symbols, "name1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "name2", target.Module.Name),
                LookupSymbolEntry(symbols, "name2"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));

            const string input2 =
                "declare function name1; " +
                    "declare function name2; ";

            ldr.LoadFromString(input2);
            Assert.AreEqual(0, ldr.ErrorCount);
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "name1", target.Module.Name), LookupSymbolEntry(symbols, "name1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "name2", target.Module.Name), LookupSymbolEntry(symbols, "name2"));
        }
Beispiel #11
0
        public void Declare()
        {
            const string input =
                "declare function f\\1; " +
                "declare var go\\1; " +
                "declare ref gf\\1, gf\\2; " +
                "declare function if\\1;";
            var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
            var ldr = new Loader(opt);
            ldr.LoadFromString(input);
            Assert.AreEqual(0, ldr.ErrorCount);
            var symbols = ldr.TopLevelSymbols;

            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "f\\1", target.Module.Name), LookupSymbolEntry(symbols, @"f\1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalObjectVariable, "go\\1", target.Module.Name),
                LookupSymbolEntry(symbols, @"go\1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "gf\\1", target.Module.Name),
                LookupSymbolEntry(symbols, @"gf\1"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.GlobalReferenceVariable, "gf\\2", target.Module.Name),
                LookupSymbolEntry(symbols, @"gf\2"));
            Assert.AreEqual(
                new SymbolEntry(SymbolInterpretations.Function, "if\\1", target.Module.Name), LookupSymbolEntry(symbols, @"if\1"));
        }
Beispiel #12
0
        public void AddingMetadata()
        {
            const string input1 =
                "MyList { elem1, elem2, elem3 };";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);

            Assert.AreEqual(0, ldr.ErrorCount);

            Assert.IsTrue(target.Meta.ContainsKey("MyList"), "MyList missing");
            Assert.IsTrue(target.Meta["MyList"].IsList, "MyList should be a list");
            Assert.AreEqual(3, target.Meta["MyList"].List.Length);
            Assert.AreEqual("elem2", target.Meta["MyList"].List[1].Text);

            const string input2 =
                "Add elem4 to MyList;";
            ldr.LoadFromString(input2);

            Assert.AreEqual(0, ldr.ErrorCount);

            Assert.IsTrue(target.Meta.ContainsKey("MyList"), "MyList missing after modification");
            Assert.IsTrue(
                target.Meta["MyList"].IsList, "MyList should be a list, even after modification");
            Assert.AreEqual(4, target.Meta["MyList"].List.Length);
            Assert.AreEqual("elem4", target.Meta["MyList"].List[3].Text);

            const string input3 =
                "Add { elem5, elem6 } to MyList;";
            ldr.LoadFromString(input3);

            Assert.AreEqual(0, ldr.ErrorCount);

            Assert.IsTrue(
                target.Meta.ContainsKey("MyList"), "MyList missing after 2nd modification");
            Assert.IsTrue(
                target.Meta["MyList"].IsList, "MyList should be a list, even after 2nd modification");
            Assert.AreEqual(6, target.Meta["MyList"].List.Length);
            Assert.AreEqual("elem6", target.Meta["MyList"].List[5].Text);

            const string input4 =
                @"Import 
{
    System,
    System::Text
};

Add System::Xml to Imports;
";
            ldr.LoadFromString(input4);
            Assert.AreEqual(0, ldr.ErrorCount, "There were errors during compilator of input4");
            Assert.IsTrue(target.Meta.ContainsKey("Import"), "Import missing");
            Assert.IsTrue(
                target.Meta["Import"].IsList, "Import should be a list after 2nd modification");
            Assert.AreEqual(3, target.Meta["Import"].List.Length);
            Assert.AreEqual("System", target.Meta["Import"].List[0].Text);
            Assert.AreEqual("System.Text", target.Meta["Import"].List[1].Text);
            Assert.AreEqual("System.Xml", target.Meta["Import"].List[2].Text);
        }
Beispiel #13
0
        public void NestedMetadata()
        {
            const string input1 =
                "FirstList { \"first String\", firstId, true, 55 } ;" +
                    "SecondList { \"second String\", { \"first }}Nested{ string\", secondNestedId }, thirdId }; ";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);

            Assert.AreEqual(0, ldr.ErrorCount);

            //First list
            Assert.IsTrue(target.Meta.ContainsKey("firstList"), "firstList missing");
            Assert.IsTrue(target.Meta["firstList"].IsList, "firstList should be a list");
            Assert.AreEqual("first String", target.Meta["firstList"].List[0].Text);
            Assert.AreEqual("firstId", target.Meta["firstList"].List[1].Text);
            Assert.AreEqual(true, target.Meta["firstList"].List[2].Switch);
            Assert.AreEqual("55", target.Meta["firstList"].List[3].Text);

            //Second list
            Assert.IsTrue(target.Meta.ContainsKey("secondList"), "secondList missing");
            Assert.IsTrue(target.Meta["secondList"].IsList, "secondList should be a list");
            Assert.AreEqual("second String", target.Meta["secondList"].List[0].Text);
            Assert.IsTrue(
                target.Meta["secondList"].List[1].IsList, "second element should be a list");
            Assert.AreEqual(
                "first }}Nested{ string", target.Meta["secondList"].List[1].List[0].Text);
            Assert.AreEqual("secondNestedId", target.Meta["secondList"].List[1].List[1].Text);
            Assert.AreEqual("thirdId", target.Meta["secondList"].List[2].Text);
        }
Beispiel #14
0
 private Loader _justCompile(string input)
 {
     var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
     var ldr = new Loader(opt);
     ldr.LoadFromString(input);
     return ldr;
 }
Beispiel #15
0
        public void AsmIntInstructions()
        {
            const string input1 =
                @"
function func1 does asm
{
    ldc.int 1           //0
    ldc.int -58416325   //1
    pop     1           //2
    pop     10          //3
    dup     2           //4
    dup     10          //5
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");

            var code = target.Functions["func1"].Code;
            var i = 0;

            Assert.AreEqual(OpCode.ldc_int, code[i].OpCode);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.ldc_int, code[i].OpCode);
            Assert.AreEqual(-58416325, code[i++].Arguments);

            Assert.AreEqual(OpCode.pop, code[i].OpCode);
            Assert.AreEqual(1, code[i++].Arguments);

            Assert.AreEqual(OpCode.pop, code[i].OpCode);
            Assert.AreEqual(10, code[i++].Arguments);

            Assert.AreEqual(OpCode.dup, code[i].OpCode);
            Assert.AreEqual(2, code[i++].Arguments);

            Assert.AreEqual(OpCode.dup, code[i].OpCode);
            Assert.AreEqual(10, code[i++].Arguments);
        }
Beispiel #16
0
        public void ExpressionFunctions()
        {
            const string input1 = @"
function twice(x) = 2*x;
function megabyte = 1024*1024;
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");

            //check "twice"
            var actual = target.Functions["twice"].Code;
            var expected = GetInstructions(@"
ldc.int 2
ldloc x
mul
ret.value
");

            Console.Write(target.StoreInString());

            Assert.AreEqual(
                expected.Count,
                actual.Count,
                "Expected and actual instruction count missmatch in twice.");

            for (var i = 0; i < actual.Count; i++)
                Assert.AreEqual(
                    expected[i],
                    actual[i],
                    String.Format(
                        "Twice: Instructions at address {0} do not match ({1} != {2})",
                        i,
                        expected[i],
                        actual[i]));

            //check "megabyte"
            actual = target.Functions["megabyte"].Code;
            expected = GetInstructions(@"
ldc.int 1048576
ret.value
");

            Assert.AreEqual(
                expected.Count,
                actual.Count,
                "Expected and actual instruction count missmatch in megabyte.");

            for (var i = 0; i < actual.Count; i++)
                Assert.AreEqual(
                    expected[i],
                    actual[i],
                    String.Format(
                        "Megabyte: Instructions at address {0} do not match ({1} != {2})",
                        i,
                        expected[i],
                        actual[i]));
        }
Beispiel #17
0
        public void AsmLabelsAndJumps()
        {
            const string input1 =
                @"
function func1 does asm
{
    jump        14
    ldc.bool    true
    jump.t      14
    jump.f      5
    
    //a while loop
    var i
    ldc.int     5
    stloc       i
    label       while0
    ldloc       i
    ldc.int     0
    cgt
    jump.f      endwhile0
    ldloc       i
    sget.1      ""Object(\""System.Console\"")::WriteLine""
    dec         i
    jump        while0
    label       endwhile0
}
";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");

            var code = target.Functions["func1"].Code;

            Assert.AreEqual(OpCode.jump, code[0].OpCode);
            Assert.AreEqual(14, code[0].Arguments);

            Assert.AreEqual(OpCode.jump_t, code[2].OpCode);
            Assert.AreEqual(14, code[2].Arguments);

            Assert.AreEqual(OpCode.jump_f, code[3].OpCode);
            Assert.AreEqual(5, code[3].Arguments);

            //The while loop
            Assert.AreEqual(OpCode.jump, code[13].OpCode);
            Assert.AreEqual(6, code[13].Arguments);

            Assert.AreEqual(OpCode.jump_f, code[9].OpCode);
            Assert.AreEqual(14, code[9].Arguments);
        }
Beispiel #18
0
        public void EmptyAsmFunction()
        {
            const string input1 =
                @"
//minimalistic
function func1 does asm {} 

//normal
function func2(param1, param2, param3) does asm
{  /* a comment */  } 

//*bling-bling*
function func3(param1, param2)
    [ Add System::IO to Imports; ] does asm
{ 

    }";
            var opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            var ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            //func1
            Assert.IsTrue(target.Functions.Contains("func1"), "func1 is not in the function table");
            Assert.AreEqual(SymbolInterpretations.Function, LookupSymbolEntry(ldr.TopLevelSymbols, "func1").Interpretation);
            Assert.AreEqual(0, target.Functions["func1"].Parameters.Count);

            Assert.IsTrue(target.Functions.Contains("func2"), "func2 is not in the function table");
            Assert.AreEqual(SymbolInterpretations.Function, LookupSymbolEntry(ldr.TopLevelSymbols, "func2").Interpretation);
            Assert.AreEqual(3, target.Functions["func2"].Parameters.Count);
            Assert.AreEqual("param2", target.Functions["func2"].Parameters[1]);

            Assert.IsTrue(target.Functions.Contains("func3"), "func3 is not in the function table");
            Assert.AreEqual(SymbolInterpretations.Function, LookupSymbolEntry(ldr.TopLevelSymbols, "func3").Interpretation);
            Assert.AreEqual(2, target.Functions["func3"].Parameters.Count);
            Assert.AreEqual("param2", target.Functions["func3"].Parameters[1]);
            Assert.AreEqual(1, target.Functions["func3"].ImportedNamespaces.Count);
        }
        /// <summary>
        /// Prints a stored representation of each application in the compound that has its "request_dump" flag set.
        /// </summary>
        public void PrintCompound()
        {
            var tasks =
                Application.Compound.Where(app => app.Meta[DumpRequestFlag].Switch).Select(
                    app =>
                    new KeyValuePair<ModuleName, Task<ITarget>>(app.Module.Name, ModuleCache.BuildAsync(app.Module.Name)))
                    .ToDictionary(k => k.Key, k => k.Value);
            foreach (var entry in tasks)
            {
                var name = entry.Key;
                var target = entry.Value.Result;

                Console.WriteLine();
                Console.WriteLine("##################################  begin of stored representation for {0} ",name);

                var opt = new LoaderOptions(Engine, new Application(target.Module), target.Symbols)
                    {ReconstructSymbols = false, RegisterCommands = false, StoreSymbols = true};
                var ldr = new Loader(opt);
                ldr.Store(Console.Out);

                Console.WriteLine("##################################    end of stored representation for {0} ----------", name);
            }
        }
Beispiel #20
0
        public void ExplicitGotos()
        {
            const string input1 =
                @"
declare function instruction;

function func0
{
begin:  instruction;        //1
        goto    fifth;      //2
third : instruction;        //3
fourth: goto    sixth;      //4
fifth:  goto    fourth;     //5
sixth:  goto    begin;      //6
}

function instruction {}
";
            LoaderOptions opt = new LoaderOptions(engine, target);
            opt.UseIndicesLocally = false;
            Loader ldr = new Loader(opt);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount, "Errors during compilation.");

            //Check AST
            AstBlock block = ldr.FunctionTargets["func0"].Ast;

            //label begin
            int i = 0;
            Assert.IsInstanceOf(typeof(AstExplicitLabel), block[i]);
            Assert.AreEqual("begin", ((AstExplicitLabel) block[i]).Label);

            //instruction
            i++;
            Assert.IsInstanceOf(typeof(AstIndirectCall), block[i]);
            Assert.AreEqual(PCall.Get, ((AstGetSet) block[i]).Call);
            Assert.AreEqual(0, ((AstGetSet) block[i]).Arguments.Count);

            //goto fith
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitGoTo), block[i]);
            Assert.AreEqual("fifth", ((AstExplicitGoTo) block[i]).Destination);

            //label third
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitLabel), block[i]);
            Assert.AreEqual("third", ((AstExplicitLabel) block[i]).Label);

            //instruction
            i++;
            Assert.IsInstanceOf(typeof(AstIndirectCall), block[i]);
            Assert.AreEqual(PCall.Get, ((AstGetSet)block[i]).Call);
            Assert.AreEqual(0, ((AstGetSet)block[i]).Arguments.Count);

            //label fourth
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitLabel), block[i]);
            Assert.AreEqual("fourth", ((AstExplicitLabel) block[i]).Label);

            //goto sixth
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitGoTo), block[i]);
            Assert.AreEqual("sixth", ((AstExplicitGoTo) block[i]).Destination);

            //label fifth
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitLabel), block[i]);
            Assert.AreEqual("fifth", ((AstExplicitLabel) block[i]).Label);

            //goto fourth
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitGoTo), block[i]);
            Assert.AreEqual("fourth", ((AstExplicitGoTo) block[i]).Destination);

            //label sixth
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitLabel), block[i]);
            Assert.AreEqual("sixth", ((AstExplicitLabel) block[i]).Label);

            //goto begin
            i++;
            Assert.IsInstanceOf(typeof(AstExplicitGoTo), block[i]);
            Assert.AreEqual("begin", ((AstExplicitGoTo) block[i]).Destination);

            Console.WriteLine(target.StoreInString());
        }