Merge pull request #99 from zaskar9/oberon-crash-course

Demo modules for Oberon and LLVM tutorials

Author: zaskar9

demo/ETH/Stuetzkurs/List.Mod

@@ -0,0 +1,146 @@
+MODULE List;
+IMPORT Out;
+
+  TYPE
+    Object* = POINTER TO ObjectDesc;
+    ObjectDesc* = RECORD
+      compare*: PROCEDURE(this, other: Object): INTEGER;
+      print*: PROCEDURE(this: Object)
+    END;
+    Element = POINTER TO ElementDesc;
+    ElementDesc = RECORD
+      value: Object;
+      next: Element
+    END;
+    List* = POINTER TO ListDesc;
+    ListDesc* = RECORD
+      first, last: Element;
+      insert*: PROCEDURE(this: List; o: Object);
+      delete*: PROCEDURE(this: List; o: Object);
+      print*: PROCEDURE(this: List)
+    END;
+
+    (* Developer-defined types. *)
+    Integer* = POINTER TO IntegerDesc;
+    IntegerDesc* = RECORD (ObjectDesc)
+      value*: INTEGER
+    END;
+
+  VAR
+    i: INTEGER;
+    value: Integer;
+    l: List;
+
+  PROCEDURE compareInt(this, other: Object): INTEGER;
+  BEGIN
+    RETURN this(Integer).value - other(Integer).value
+  END compareInt;
+
+  PROCEDURE printInt(this: Object);
+  BEGIN
+    Out.Int(this(Integer).value, 0)
+  END printInt;
+
+  PROCEDURE newInt(value: INTEGER): Integer;
+  VAR res: Integer;
+  BEGIN
+    NEW(res);
+    res.value := value;
+    res.compare := compareInt;
+    res.print := printInt;
+    RETURN res
+  END newInt;
+
+  PROCEDURE insert(l: List; o: Object);
+  VAR e: Element;
+  BEGIN
+    NEW(e);
+    e.value := o;
+    e.next := NIL;
+    IF l.first # NIL THEN
+      l.last.next := e
+    ELSE
+      l.first := e
+    END;
+    l.last := e
+  END insert;
+
+  PROCEDURE delete(l: List; o: Object);
+  VAR cur, prev: Element;
+      val: Object;
+  BEGIN
+    cur := l.first;
+    prev := NIL;
+    WHILE cur # NIL DO
+      val := cur.value;
+      IF val.compare(val, o) = 0 THEN
+        IF prev # NIL THEN
+          prev.next := cur.next;
+          IF cur = l.last THEN
+            l.last := prev
+          END
+        ELSE
+          l.first := cur.next
+        END;
+        DISPOSE(cur.value);
+        DISPOSE(cur);
+        EXIT
+      ELSE
+        prev := cur;
+        cur := cur.next
+      END
+    END
+  END delete;
+
+  PROCEDURE print(l: List);
+  VAR cur: Element;
+      val: Object;
+  BEGIN
+    cur := l.first;
+    Out.Char("[");
+    WHILE cur # NIL DO
+      val := cur.value;
+      val.print(val);
+      cur := cur.next;
+      IF (cur # NIL) THEN Out.Char(",") END
+    END;
+    Out.Char("]")
+  END print;
+
+  PROCEDURE newList*(): List;
+  VAR l: List;
+  BEGIN
+    NEW(l);
+    l.first := NIL; l.last := NIL;
+    l.insert := insert;
+    l.delete := delete;
+    l.print := print;
+    RETURN l
+  END newList;
+
+  PROCEDURE deleteList*(l: List);
+  VAR cur, tmp: Element;
+  BEGIN
+    cur := l.first;
+    WHILE cur # NIL DO
+      tmp := cur;
+      cur := cur.next;
+      DISPOSE(tmp.value);
+      DISPOSE(tmp)
+    END;
+    DISPOSE(l)
+  END deleteList;
+
+BEGIN
+  l := newList();
+  l.print(l); Out.Ln;
+  FOR i := 0 TO 9 DO
+    l.insert(l, newInt(i))
+  END;
+  l.print(l); Out.Ln;
+  l.delete(l, newInt(0));
+  l.delete(l, newInt(5));
+  l.delete(l, newInt(9));
+  l.print(l); Out.Ln;
+  deleteList(l)
+END List.

demo/ETH/Stuetzkurs/RealScanner.Mod

@@ -24,12 +24,12 @@ IMPORT In, Out, Reals;
     ch: CHAR;
     valid: BOOLEAN;
   BEGIN
-    val := 0; i := 0; s := 0; div := 1; scale := 0; valid := TRUE;
+    val := 0; i := 0; s := 0; div := 1; scale := 0 valid := TRUE;
     WHILE valid & (i < LEN(str)) & (str[i] # 0X) DO
       ch := str[i]; INC(i);
       CASE s OF
         0 : IF isDigit(ch) THEN
-              s := 1;
+              s := 1
               val := 10 * val + ctoi(ch)
             ELSE
               valid := FALSE

demo/ETH/Stuetzkurs/Temperatur.Mod

@@ -71,7 +71,7 @@ MODULE Temperatur;
       IF (von > nach) OR (schritt > (nach - von)) THEN
         Out.String("Gib mir doch eine Eingabe, die Sinn macht!"); Out.Ln;
       ELSE
-        WHILE von < nach DO
+        WHILE von <= nach DO
           Out.Int(von,5); Out.String(" -> ");
           Out.RealFix(CtoF(von),3,2); Out.Ln;
           von := von + schritt;
@@ -98,7 +98,7 @@ MODULE Temperatur;
 
   BEGIN
     Out.Open;
-    TabelleFor;
+    Tabelle;
   END Temperatur.
 
   Temperatur.Tabelle 0 100 10

test/c/overload.cpp

@@ -0,0 +1,12 @@
+int add(int x, int y) {
+    return x + y;
+}
+
+float add(float x, float y) {
+    return x + y;
+}
+
+int main() {
+    int i, j;
+    return add(i, j);
+}

test/oberon/LLVMProgramming1.Mod

@@ -0,0 +1,12 @@
+MODULE Demo;
+VAR
+  i*: INTEGER;
+  l: LONGINT;
+  f: REAL;
+  b: BOOLEAN;
+BEGIN
+    i := 10;
+    l := i;
+    f := l / 3;
+    b := (i - l < 10) & (i + l > 10)
+END Demo.

test/oberon/LLVMProgramming2.Mod

@@ -0,0 +1,46 @@
+MODULE LLVMProgramming2;
+
+  TYPE
+    Vector = ARRAY 100 OF INTEGER;
+    Matrix = ARRAY 10, 10 OF INTEGER;
+    Point2D = RECORD x, y: INTEGER END;
+    Triangle = ARRAY 3 OF Point2D;
+
+  VAR
+    i, j: INTEGER;
+    v: Vector;
+    m: Matrix;
+    p: Point2D;
+    t: Triangle;
+
+  PROCEDURE ["C"] PrintF(str: ARRAY OF CHAR; ...); EXTERNAL [ "printf" ];
+
+  PROCEDURE WriteInt(val: INTEGER);
+  BEGIN
+    PrintF("%d", val)
+  END WriteInt;
+
+  PROCEDURE WriteLn;
+  BEGIN
+    PrintF("\n")
+  END WriteLn;
+
+  PROCEDURE Swap(VAR i, j: INTEGER);
+  VAR t: INTEGER;
+  BEGIN
+    t := i;
+    i := j;
+    j := t
+  END Swap;
+
+  PROCEDURE Sum(x, y: INTEGER): INTEGER;
+  BEGIN
+    RETURN x + y
+  END Sum;
+
+BEGIN
+  t[2].x := 3;
+  t[2].y := t[2].x;
+  WriteInt(t[2].y);
+  WriteLn
+END LLVMProgramming2.

test/oberon/LLVMProgramming3.Mod

@@ -0,0 +1,73 @@
+MODULE LLVMProgramming3;
+
+  CONST Dim = 20;
+
+  TYPE Array = ARRAY Dim OF INTEGER;
+
+  VAR a: Array;
+
+  PROCEDURE Init;
+    VAR i: INTEGER;
+  BEGIN
+    i := 0;
+    WHILE i < Dim DO
+      a[i] := Dim-i;
+      i := i + 1
+    END
+  END Init;
+
+  PROCEDURE Swap(VAR a, b: INTEGER);
+    VAR t: INTEGER;
+  BEGIN
+    t := a; a := b; b := t
+  END Swap;
+
+  PROCEDURE BubbleSort;
+    VAR i, j: INTEGER;
+  BEGIN
+    i := 0;
+    WHILE i < Dim DO
+      j := Dim - 1;
+      WHILE j > i DO
+        IF a[j - 1] > a[j] THEN Swap(a[j - 1], a[j]) END;
+        j := j - 1
+      END;
+      i := i + 1
+    END
+  END BubbleSort;
+
+  PROCEDURE CondExec;
+    VAR i, j: INTEGER;
+  BEGIN
+    IF i > j THEN i := j ELSE j := i END
+  END CondExec;
+
+  PROCEDURE Loop;
+    VAR i, j: INTEGER;
+  BEGIN
+    i := 0; j := 1;
+    WHILE i < 10 DO
+      j := j * i;
+      i := i + 1
+    END
+  END Loop;
+
+  PROCEDURE Case;
+    VAR x, y: INTEGER;
+        ch: CHAR;
+  BEGIN
+    x := 0; y := 0;
+    CASE ch OF
+        "n": x := -1
+      | "s": x := 1
+      | "w": y := -1
+      | "e": y := 1
+    END
+  END Case;
+
+
+
+BEGIN
+  Init;
+  BubbleSort
+END LLVMProgramming3.