Changeset 051b3db8 in mainline for uspace/dist/src/sysel


Ignore:
Timestamp:
2011-03-16T23:23:21Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
306061a
Parents:
406d514
Message:

Update SBI to rev. 344 from upstream. What's new:

  • Builtin.WriteLine() renamed to Console.WriteLine()
  • Implemented 'switch' statement
  • Significantly reduced memory consumption (also increases execution speed in some cases)
  • Properties can be accessed via unqualified names
  • Exceptions raised during property accesses are now handled correctly
  • Some missing checks against expressions returning no value added
Location:
uspace/dist/src/sysel/demos
Files:
1 added
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/dist/src/sysel/demos/arith.sy

    r406d514 r051b3db8  
    3030        fun Main(), static is
    3131                -- Test addition, multiplication and precedence.
    32                 Builtin.Write("2*2 + 2*2 = ");
    33                 Builtin.Write(2*2 + 2*2);
    34                 Builtin.WriteLine(" (expected: 8)");
     32                Console.Write("2*2 + 2*2 = ");
     33                Console.Write(2*2 + 2*2);
     34                Console.WriteLine(" (expected: 8)");
    3535
    3636                -- Test subtraction, multiplication and precedence.
    37                 Builtin.Write("1111 - 1 - 10 - 10*10 - 10*10*10 = ");
    38                 Builtin.Write(1111 - 1 - 10 - 10*10 - 10*10*10);
    39                 Builtin.WriteLine(" (expected: 0)");
     37                Console.Write("1111 - 1 - 10 - 10*10 - 10*10*10 = ");
     38                Console.Write(1111 - 1 - 10 - 10*10 - 10*10*10);
     39                Console.WriteLine(" (expected: 0)");
    4040
    4141                -- Test parenthesized sub-expressions.
    42                 Builtin.Write("10 * (1 - 1) = ");
    43                 Builtin.Write(10 * (1 - 1));
    44                 Builtin.WriteLine(" (expected: 0)");
     42                Console.Write("10 * (1 - 1) = ");
     43                Console.Write(10 * (1 - 1));
     44                Console.WriteLine(" (expected: 0)");
    4545
    4646                -- Test unary plus and minus.
    47                 Builtin.Write("(+1) - (-1) - (+(+1)) + (+(-1)) = ");
    48                 Builtin.Write((+1) - (-1) - (+(+1)) + (+(-1)));
    49                 Builtin.WriteLine(" (expected: 0)");
     47                Console.Write("(+1) - (-1) - (+(+1)) + (+(-1)) = ");
     48                Console.Write((+1) - (-1) - (+(+1)) + (+(-1)));
     49                Console.WriteLine(" (expected: 0)");
    5050
    5151                -- Test signed multiplication.
    52                 Builtin.Write("+1 * +1 = ");
    53                 Builtin.Write(+1 * +1);
    54                 Builtin.WriteLine(" (expected: 1)");
     52                Console.Write("+1 * +1 = ");
     53                Console.Write(+1 * +1);
     54                Console.WriteLine(" (expected: 1)");
    5555
    56                 Builtin.Write("-1 * -1 = ");
    57                 Builtin.Write(-1 * -1);
    58                 Builtin.WriteLine(" (expected: 1)");
     56                Console.Write("-1 * -1 = ");
     57                Console.Write(-1 * -1);
     58                Console.WriteLine(" (expected: 1)");
    5959
    60                 Builtin.Write("+1 * -1 = ");
    61                 Builtin.Write(+1 * -1);
    62                 Builtin.WriteLine(" (expected: -1)");
     60                Console.Write("+1 * -1 = ");
     61                Console.Write(+1 * -1);
     62                Console.WriteLine(" (expected: -1)");
    6363
    64                 Builtin.Write("-1 * +1 = ");
    65                 Builtin.Write(-1 * +1);
    66                 Builtin.WriteLine(" (expected: -1)");
     64                Console.Write("-1 * +1 = ");
     65                Console.Write(-1 * +1);
     66                Console.WriteLine(" (expected: -1)");
    6767
    6868                -- Test multiplication with large result.
    69                 Builtin.Write("1000000 * 1000000 * 1000000 * 1000000 = ");
    70                 Builtin.Write(1000000 * 1000000 * 1000000 * 1000000);
    71                 Builtin.WriteLine(" (expected: 1000000000000000000000000)");
     69                Console.Write("1000000 * 1000000 * 1000000 * 1000000 = ");
     70                Console.Write(1000000 * 1000000 * 1000000 * 1000000);
     71                Console.WriteLine(" (expected: 1000000000000000000000000)");
    7272
    7373                -- Test large literals.
    74                 Builtin.Write("1000000000000000000000000 = ");
    75                 Builtin.Write(1000000000000000000000000);
    76                 Builtin.WriteLine(" (expected: 1000000000000000000000000)");
     74                Console.Write("1000000000000000000000000 = ");
     75                Console.Write(1000000000000000000000000);
     76                Console.WriteLine(" (expected: 1000000000000000000000000)");
    7777
    7878                -- Test large factorials.
    7979                var n : int;
    8080
    81                 Builtin.WriteLine("Factorials:");
     81                Console.WriteLine("Factorials:");
    8282                n = 1;
    8383                while n <= 40 do
    84                         Builtin.WriteLine(Factorial(n));
     84                        Console.WriteLine(Factorial(n));
    8585                        n = n + 1;
    8686                end

  • uspace/dist/src/sysel/demos/array.sy

    r406d514 r051b3db8  
    4040                i = 0;
    4141                while i < 3 do
    42                         Builtin.WriteLine(a[i, 0]);
     42                        Console.WriteLine(a[i, 0]);
    4343                        i = i + 1;
    4444                end

  • uspace/dist/src/sysel/demos/autobox.sy

    r406d514 r051b3db8  
    3939                --
    4040                b = true;
    41                 Builtin.WriteLine(b.Value);
     41                Console.WriteLine(b.Value);
    4242                c = 'a';
    43                 Builtin.WriteLine(c.Value);
     43                Console.WriteLine(c.Value);
    4444                i = 1;
    45                 Builtin.WriteLine(i.Value);
     45                Console.WriteLine(i.Value);
    4646                s = "Hello";
    47                 Builtin.WriteLine(s.Value);
     47                Console.WriteLine(s.Value);
    4848
    4949                -- Anything can be converted to Object.

  • uspace/dist/src/sysel/demos/count.sy

    r406d514 r051b3db8  
    3333                i = a;
    3434                while i < b do
    35                         Builtin.WriteLine(i);
     35                        Console.WriteLine(i);
    3636                        i = i + 1;
    3737                end

  • uspace/dist/src/sysel/demos/ctor.sy

    r406d514 r051b3db8  
    3232
    3333                a = new A(1);
    34                 Builtin.Write("a.v = ");
    35                 Builtin.WriteLine(a.v);
     34                Console.Write("a.v = ");
     35                Console.WriteLine(a.v);
    3636        end
    3737end
    … …  
    4141
    4242        new(i : int) is
    43                 Builtin.WriteLine("A.new()");
     43                Console.WriteLine("A.new()");
    4444                v = i;
    4545        end

  • uspace/dist/src/sysel/demos/deleg.sy

    r406d514 r051b3db8  
    5555        -- Function having delegate as the first parameger
    5656        fun Operate(op : BinaryOp; opName : string) is
    57                 Builtin.Write(opName + "(1, 2): ");
    58                 Builtin.WriteLine(op(1, 2));
     57                Console.Write(opName + "(1, 2): ");
     58                Console.WriteLine(op(1, 2));
    5959        end
    6060

  • uspace/dist/src/sysel/demos/enum.sy

    r406d514 r051b3db8  
    3131                var color : ChessColor;
    3232
    33                 Builtin.WriteLine("Set color to ChessColor.Black.");
     33                Console.WriteLine("Set color to ChessColor.Black.");
    3434                color = ChessColor.Black;
    3535
    36                 Builtin.Write("Test color == ChessColor.Black.. ");
     36                Console.Write("Test color == ChessColor.Black.. ");
    3737                if color == ChessColor.Black then
    38                         Builtin.WriteLine("True - OK");
     38                        Console.WriteLine("True - OK");
    3939                else
    40                         Builtin.WriteLine("False - Fail!");
     40                        Console.WriteLine("False - Fail!");
    4141                        raise new Error.Base();
    4242                end
    4343
    44                 Builtin.Write("Test color != ChessColor.Black.. ");
     44                Console.Write("Test color != ChessColor.Black.. ");
    4545                if color != ChessColor.Black then
    46                         Builtin.WriteLine("True - Fail!");
     46                        Console.WriteLine("True - Fail!");
    4747                        raise new Error.Base();
    4848                else
    49                         Builtin.WriteLine("False - OK");
     49                        Console.WriteLine("False - OK");
    5050                end
    5151
    52                 Builtin.Write("Test color == ChessColor.White.. ");
     52                Console.Write("Test color == ChessColor.White.. ");
    5353                if color == ChessColor.White then
    54                         Builtin.WriteLine("True - Fail!");
     54                        Console.WriteLine("True - Fail!");
    5555                        raise new Error.Base();
    5656                else
    57                         Builtin.WriteLine("False - OK");
     57                        Console.WriteLine("False - OK");
    5858                end
    5959
    60                 Builtin.Write("Test color != ChessColor.White.. ");
     60                Console.Write("Test color != ChessColor.White.. ");
    6161                if color != ChessColor.White then
    62                         Builtin.WriteLine("True - OK");
     62                        Console.WriteLine("True - OK");
    6363                else
    64                         Builtin.WriteLine("False - Fail!");
     64                        Console.WriteLine("False - Fail!");
    6565                        raise new Error.Base();
    6666                end
    6767
    68                 Builtin.WriteLine("Success");
     68                Console.WriteLine("Success");
    6969
    7070                -- Test enum declared in non-CSI scope

  • uspace/dist/src/sysel/demos/except.sy

    r406d514 r051b3db8  
    2929class ExceptionDemo is
    3030        fun foo(), static is
    31                 Builtin.WriteLine("Entered foo().");
     31                Console.WriteLine("Entered foo().");
    3232                raise new BaseException();
    3333        end
    … …  
    3838                        foo();
    3939                except e : DerivedException do
    40                         Builtin.WriteLine("Caught derived exception.");
     40                        Console.WriteLine("Caught derived exception.");
    4141                except e : BaseException do
    42                         Builtin.WriteLine("Caught base exception.");
     42                        Console.WriteLine("Caught base exception.");
    4343                finally do
    44                         Builtin.WriteLine("Finally.");
     44                        Console.WriteLine("Finally.");
    4545                end
    4646        end

  • uspace/dist/src/sysel/demos/gen.sy

    r406d514 r051b3db8  
    3131class GenericsDemo is
    3232        fun Main(), static is
    33                 Builtin.WriteLine("Let's try some generics.");
     33                Console.WriteLine("Let's try some generics.");
    3434
    3535                var f : B/int/string;

  • uspace/dist/src/sysel/demos/hello.sy

    r406d514 r051b3db8  
    2929class HelloWorld is
    3030        fun Main(), static is
    31                 Builtin.WriteLine("Hello world!");
     31                Console.WriteLine("Hello world!");
    3232        end
    3333end

  • uspace/dist/src/sysel/demos/htxtfile.sy

    r406d514 r051b3db8  
    4545                while not in_file.EOF do
    4646                        line = in_file.ReadLine();
    47                         Builtin.WriteLine(name + ": " + line);
     47                        Console.WriteLine(name + ": " + line);
    4848                        out_file.WriteLine(name + ": " + line);
    4949                end

  • uspace/dist/src/sysel/demos/iface.sy

    r406d514 r051b3db8  
    4343                f = g as Foo;
    4444
    45                 Builtin.WriteLine(g.a());
     45                Console.WriteLine(g.a());
    4646        end
    4747end

  • uspace/dist/src/sysel/demos/inherit.sy

    r406d514 r051b3db8  
    2929class A is
    3030        fun Foo() is
    31                 Builtin.WriteLine("A.Foo()");
     31                Console.WriteLine("A.Foo()");
    3232        end
    3333end
    … …  
    3535class B : A is
    3636        fun Foo() is
    37                 Builtin.WriteLine("B.Foo()");
     37                Console.WriteLine("B.Foo()");
    3838        end
    3939end

  • uspace/dist/src/sysel/demos/list.sy

    r406d514 r051b3db8  
    4343                e = list.GetEnumerator();
    4444                while e.MoveNext() do
    45                         Builtin.WriteLine(e.Data);
     45                        Console.WriteLine(e.Data);
    4646                end
    4747        end

  • uspace/dist/src/sysel/demos/map.sy

    r406d514 r051b3db8  
    4343                e = map.GetEnumerator();
    4444                while e.MoveNext() do
    45                         Builtin.Write(e.Data);
    46                         Builtin.Write(" -> ");
    47                         Builtin.WriteLine(map[e.Data]);
     45                        Console.Write(e.Data);
     46                        Console.Write(" -> ");
     47                        Console.WriteLine(map[e.Data]);
    4848                end
    4949        end

  • uspace/dist/src/sysel/demos/property.sy

    r406d514 r051b3db8  
    3333        prop X : int is
    3434                get is
    35                         Builtin.Write("Getting value of X which is ");
    36                         Builtin.WriteLine(x);
     35                        Console.Write("Getting value of X which is ");
     36                        Console.WriteLine(x);
    3737                        return x;
    3838                end
    3939
    4040                set value is
    41                         Builtin.Write("Setting value of X to ");
    42                         Builtin.WriteLine(value);
     41                        Console.Write("Setting value of X to ");
     42                        Console.WriteLine(value);
    4343                        x = value;
    4444                end
     45        end
     46
     47        -- Test accessing property via an unqualified name
     48        fun TestUnqualPropAcc() is
     49                var i : int;
     50
     51                X = 1;
     52                i = X;
     53
     54                Console.Write("TestUnqualPropAcc(): Got ");
     55                Console.WriteLine(i);
    4556        end
    4657
    … …  
    5162        prop self[index : int] : int is
    5263                get is
    53                         Builtin.Write("Getting property with index ");
    54                         Builtin.Write(index);
    55                         Builtin.Write(" which is ");
    56                         Builtin.WriteLine(iprops[index]);
     64                        Console.Write("Getting property with index ");
     65                        Console.Write(index);
     66                        Console.Write(" which is ");
     67                        Console.WriteLine(iprops[index]);
    5768
    5869                        return iprops[index];
    … …  
    6071
    6172                set value is
    62                         Builtin.Write("Setting property with index ");
    63                         Builtin.Write(index);
    64                         Builtin.Write(" to ");
    65                         Builtin.WriteLine(value);
     73                        Console.Write("Setting property with index ");
     74                        Console.Write(index);
     75                        Console.Write(" to ");
     76                        Console.WriteLine(value);
    6677
    6778                        iprops[index] = value;
    … …  
    8293        prop B : Bar is
    8394                get is
    84                         Builtin.WriteLine("Getting B");
     95                        Console.WriteLine("Getting B");
    8596                        return bprop;
    8697                end
    8798                set value is
    88                         Builtin.WriteLine("Setting B");
     99                        Console.WriteLine("Setting B");
    89100                        bprop = value;
    90101                end
    … …  
    110121                i = a.X;
    111122
    112                 Builtin.Write("Main(): Got ");
    113                 Builtin.WriteLine(i);
     123                Console.Write("Main(): Got ");
     124                Console.WriteLine(i);
     125
     126                a.TestUnqualPropAcc();
    114127
    115128                a.iprops = new int[5];
    … …  
    121134                i = a[1];
    122135
    123                 Builtin.Write("Main(): Got ");
    124                 Builtin.WriteLine(i);
     136                Console.Write("Main(): Got ");
     137                Console.WriteLine(i);
    125138
    126139                -- Property field access
    … …  
    132145                a.bprop = b;
    133146
    134                 Builtin.WriteLine(a.bprop.i);
     147                Console.WriteLine(a.bprop.i);
    135148                a.bprop.i = 2;
    136                 Builtin.WriteLine(a.bprop.i);
     149                Console.WriteLine(a.bprop.i);
    137150        end
    138151end

  • uspace/dist/src/sysel/demos/string.sy

    r406d514 r051b3db8  
    3030        fun Main(), static is
    3131                -- Concatenate some strings.
    32                 Builtin.WriteLine("One-" + "two-" + "three!");
     32                Console.WriteLine("One-" + "two-" + "three!");
    3333
    3434                -- Extract characters from a string.
    … …  
    3636                i = 0;
    3737                while i < 5 do
    38                         Builtin.WriteLine("ABCDE"[i]);
     38                        Console.WriteLine("ABCDE"[i]);
    3939                        i = i + 1;
    4040                end
    4141
    42                 Builtin.WriteLine("Abracadabra".Slice(2, 4));
     42                Console.WriteLine("Abracadabra".Slice(2, 4));
    4343        end
    4444end

  • uspace/dist/src/sysel/demos/svar.sy

    r406d514 r051b3db8  
    3131                -- Test static member variable
    3232                A.B.a = 1;
    33                 Builtin.WriteLine(A.B.a);
     33                Console.WriteLine(A.B.a);
    3434                A.B.a = 2;
    35                 Builtin.WriteLine(A.B.a);
     35                Console.WriteLine(A.B.a);
    3636
    3737                -- Test static property
    3838                A.B.P = 1;
    39                 Builtin.WriteLine(A.B.P);
     39                Console.WriteLine(A.B.P);
    4040                A.B.P = 2;
    41                 Builtin.WriteLine(A.B.P);
     41                Console.WriteLine(A.B.P);
    4242        end
    4343end

  • uspace/dist/src/sysel/demos/varargs.sy

    r406d514 r051b3db8  
    4444                        -- implemented...
    4545                        do
    46                                 Builtin.WriteLine(args[i]);
     46                                Console.WriteLine(args[i]);
    4747                        except e : Error.OutOfBounds do
    4848                                error = true;
Note: See TracChangeset for help on using the changeset viewer.