C# Loader.LoadFromString方法代码示例

        public void TestMeta()
        {
            const string input1 =
                @"
Name fixture\storage\meta;
Description ""Contains dummy meta information for a unit test"";
Author SealedSun;

Import 
{
    System,
    System::Text
};

Is AsFastAsPossible;

Add System::Xml To Imports;
";
            var ldr = new Loader(engine, target);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            var stored = ldr.Options.TargetApplication.StoreInString();
            Console.WriteLine(stored);

            var reldr = new Loader(engine, new Application());
            reldr.LoadFromString(stored);
            var restored = reldr.Options.TargetApplication.StoreInString();

            Assert.That(stored,
                Is.EqualTo(stored).Using((IEqualityComparer<string>)Engine.DefaultStringComparer),
                _storedShouldBeEqual);
        }

 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;
 }

        public void TestEmpty()
        {
            const string input1 = "";
            var ldr = new Loader(engine, target);
            Console.WriteLine("-- Compiling fixture");
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            var stored = ldr.Options.TargetApplication.StoreInString();
            Console.WriteLine(stored);

            Console.WriteLine("-- Compiling stored result");
            var reldr = new Loader(engine, new Application());
            reldr.LoadFromString(stored);
            var restored = reldr.Options.TargetApplication.StoreInString();

            Assert.That(stored,
                Is.EqualTo(stored).Using((IEqualityComparer<string>) Engine.DefaultStringComparer),
                _storedShouldBeEqual);
        }

        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);
        }

        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);
        }

        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);
        }

        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);
//.........这里部分代码省略.........

        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"));
        }

        public void TestDeclarations()
        {
            const string input1 =
                @"
var obj0;
var obj1;
ref func0 
[
    Description ""Contains a constant value"";
    is constant;
    UsedBy func1;    
];

ref func2;

function func1 does asm {}

ref func0 [ Add func2 to UsedBy; ];

function func2(arg0, arg1, arg2)
[
    Uses { func0, func1 };
]
{//line# 20
    goto L1;
    L0:;
    func0();
    goto LE;
    L1:;
    func1();
    goto L0;
    LE:;
}
";
            var ldr = new Loader(engine, target);
            ldr.LoadFromString(input1);
            Assert.AreEqual(0, ldr.ErrorCount);

            var stored = ldr.Options.TargetApplication.StoreInString();
            Console.WriteLine("//== 1st Store");
            Console.WriteLine(stored);

            var reldr = new Loader(engine, new Application());
            reldr.LoadFromString(stored);
            var restored = reldr.Options.TargetApplication.StoreInString();
            Console.WriteLine("//== 2nd Store");
            Console.WriteLine(restored);

            //The two of them are not supposed to be equal because of a debug feature
            /*Assert.IsTrue(Engine.StringsAreEqual(stored, restored),
                storedShouldBeEqual); //*/
        }

        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"]);
        }

        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"));
        }

        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"));
        }

        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);
        }

        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);
        }

 private Loader _justCompile(string input)
 {
     var opt = new LoaderOptions(engine, target) {UseIndicesLocally = false};
     var ldr = new Loader(opt);
     ldr.LoadFromString(input);
     return ldr;
 }