Changeset 38aaacc2 in mainline for uspace/dist/src/sysel/demos


Ignore:
Timestamp:
2010-04-23T21:41:10Z (16 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f4f866c
Parents:
074444f
Message:

Update SBI to rev. 207.

Location:
uspace/dist/src/sysel/demos
Files:
3 added
3 edited

Legend:

Unmodified
Added
Removed

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

    r074444f r38aaacc2  
    3030        fun Main() is
    3131                -- Test addition, multiplication and precedence.
    32                 Builtin.WriteLine("2*2 + 2*2 =");
    33                 Builtin.WriteLine(2*2 + 2*2);
    34                 Builtin.WriteLine("(expected: 8)");
     32                Builtin.Write("2*2 + 2*2 = ");
     33                Builtin.Write(2*2 + 2*2);
     34                Builtin.WriteLine(" (expected: 8)");
    3535
    3636                -- Test subtraction, multiplication and precedence.
    37                 Builtin.WriteLine("1111 - 1 - 10 - 10*10 - 10*10*10 =");
    38                 Builtin.WriteLine(1111 - 1 - 10 - 10*10 - 10*10*10);
    39                 Builtin.WriteLine("(expected: 0)");
     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)");
    4040
    4141                -- Test parenthesized sub-expressions.
    42                 Builtin.WriteLine("10 * (1 - 1) =");
    43                 Builtin.WriteLine(10 * (1 - 1));
    44                 Builtin.WriteLine("(expected: 0)");
     42                Builtin.Write("10 * (1 - 1) = ");
     43                Builtin.Write(10 * (1 - 1));
     44                Builtin.WriteLine(" (expected: 0)");
    4545
    4646                -- Test unary plus and minus.
    47                 Builtin.WriteLine("(+1) - (-1) - (+(+1)) + (+(-1)) = ");
    48                 Builtin.WriteLine((+1) - (-1) - (+(+1)) + (+(-1)));
    49                 Builtin.WriteLine("(expected: 0)");
     47                Builtin.Write("(+1) - (-1) - (+(+1)) + (+(-1)) = ");
     48                Builtin.Write((+1) - (-1) - (+(+1)) + (+(-1)));
     49                Builtin.WriteLine(" (expected: 0)");
    5050
    5151                -- Test signed multiplication.
    52                 Builtin.WriteLine("+1 * +1 = ");
    53                 Builtin.WriteLine(+1 * +1);
    54                 Builtin.WriteLine("(expected: 1)");
    55                 Builtin.WriteLine("-1 * -1 = ");
    56                 Builtin.WriteLine(-1 * -1);
    57                 Builtin.WriteLine("(expected: 1)");
    58                 Builtin.WriteLine("+1 * -1 = ");
    59                 Builtin.WriteLine(+1 * -1);
    60                 Builtin.WriteLine("(expected: -1)");
    61                 Builtin.WriteLine("-1 * +1 = ");
    62                 Builtin.WriteLine(-1 * +1);
    63                 Builtin.WriteLine("(expected: -1)");
     52                Builtin.Write("+1 * +1 = ");
     53                Builtin.Write(+1 * +1);
     54                Builtin.WriteLine(" (expected: 1)");
     55
     56                Builtin.Write("-1 * -1 = ");
     57                Builtin.Write(-1 * -1);
     58                Builtin.WriteLine(" (expected: 1)");
     59
     60                Builtin.Write("+1 * -1 = ");
     61                Builtin.Write(+1 * -1);
     62                Builtin.WriteLine(" (expected: -1)");
     63
     64                Builtin.Write("-1 * +1 = ");
     65                Builtin.Write(-1 * +1);
     66                Builtin.WriteLine(" (expected: -1)");
    6467
    6568                -- Test multiplication with large result.
    66                 Builtin.WriteLine("1000000 * 1000000 * 1000000 * 1000000 =");
    67                 Builtin.WriteLine(1000000 * 1000000 * 1000000 * 1000000);
    68                 Builtin.WriteLine("(expected: 1000000000000000000000000)");
     69                Builtin.Write("1000000 * 1000000 * 1000000 * 1000000 = ");
     70                Builtin.Write(1000000 * 1000000 * 1000000 * 1000000);
     71                Builtin.WriteLine(" (expected: 1000000000000000000000000)");
    6972
    7073                -- Test large literals.
    71                 Builtin.WriteLine("1000000000000000000000000 =");
    72                 Builtin.WriteLine(1000000000000000000000000);
    73                 Builtin.WriteLine("(expected: 1000000000000000000000000)");
     74                Builtin.Write("1000000000000000000000000 = ");
     75                Builtin.Write(1000000000000000000000000);
     76                Builtin.WriteLine(" (expected: 1000000000000000000000000)");
    7477
    7578                -- Test large factorials.

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

    r074444f r38aaacc2  
    3030class ListDemo is
    3131        fun Main() is
    32                 var list : List;
    33                 var i : Int;
     32                var list : List/int;
    3433
    35                 list = new List();
     34                list = new List/int();
    3635                list.Init();
    3736
    38                 -- We need autoboxing or generics to get rid of this mess.
    39                 i = new Int(); i.Value = 5; list.Append(i);
    40                 i = new Int(); i.Value = 6; list.Append(i);
    41                 i = new Int(); i.Value = 7; list.Append(i);
    42                 i = new Int(); i.Value = 8; list.Append(i);
     37                list.Append(5);
     38                list.Append(6);
     39                list.Append(7);
     40                list.Append(8);
    4341
    44                 var n : ListNode;
     42                var n : ListNode/int;
    4543
    4644                n = list.First;
    4745                while n != nil do
    48                         Builtin.WriteLine((n.value as Int).Value);
     46                        Builtin.WriteLine(n.Value);
    4947                        n = n.Next;
    5048                end

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

    r074444f r38aaacc2  
    3333        prop X : int is
    3434                get is
    35                         Builtin.WriteLine("Getting value of X which is");
     35                        Builtin.Write("Getting value of X which is ");
    3636                        Builtin.WriteLine(x);
    3737                        return x;
    … …  
    3939
    4040                set value is
    41                         Builtin.WriteLine("Setting value of X to");
     41                        Builtin.Write("Setting value of X to ");
    4242                        Builtin.WriteLine(value);
    4343                        x = value;
    … …  
    5151        prop self[index : int] : int is
    5252                get is
    53                         Builtin.WriteLine("Getting property with index ");
    54                         Builtin.WriteLine(index);
    55                         Builtin.WriteLine("which is");
     53                        Builtin.Write("Getting property with index ");
     54                        Builtin.Write(index);
     55                        Builtin.Write(" which is ");
    5656                        Builtin.WriteLine(iprops[index]);
    5757
    … …  
    6060
    6161                set value is
    62                         Builtin.WriteLine("Setting property with index ");
    63                         Builtin.WriteLine(index);
    64                         Builtin.WriteLine("to");
     62                        Builtin.Write("Setting property with index ");
     63                        Builtin.Write(index);
     64                        Builtin.Write(" to ");
    6565                        Builtin.WriteLine(value);
    6666
    … …  
    110110                i = a.X;
    111111
    112                 Builtin.WriteLine("Main(): Got ");
     112                Builtin.Write("Main(): Got ");
    113113                Builtin.WriteLine(i);
    114114
    … …  
    121121                i = a[1];
    122122
    123                 Builtin.WriteLine("Main(): Got ");
     123                Builtin.Write("Main(): Got ");
    124124                Builtin.WriteLine(i);
    125125
Note: See TracChangeset for help on using the changeset viewer.