post rebranding

examples/arguments/unixstyle_oberon_traditional/makefile

@@ -0,0 +1,11 @@
+
+VOC = /opt/voc/bin/voc
+
+
+all:
+			$(VOC) -m partest.Mod
+
+
+test:
+		./partest -str aaa -int 111
+		./partest -str 1 -int 111

examples/arguments/unixstyle_oberon_traditional/partest.Mod

@@ -0,0 +1,63 @@
+MODULE partest;
+
+IMPORT Oberon, Texts;
+
+CONST 
+  argStr0 = "str"; (* we only have two types of args, one string and one int *)
+  argInt0 = "int"; (* i. e. -str somestring -int somenumber *)
+
+VAR
+   W: Texts.Writer; (* for console output *)
+   S: Texts.Scanner; T: Texts.Text;
+BEGIN
+    Texts.OpenWriter(W);
+    Texts.WriteString(W, "hello, world, let's see which arguments do we get"); Texts.WriteLn(W);
+
+    (* open arguments scanner *)
+    Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos); 
+    
+    WHILE ~S.eot DO
+       Texts.Scan(S);
+
+       IF S.class = Texts.Char THEN (* do we get '-' sign ? *)
+         IF S.c = "-" THEN
+           Texts.Scan(S);
+           IF S.class = Texts.Name THEN (* we got the key *)
+             Texts.WriteString(W, "key: "); Texts.WriteString(W, S.s); Texts.WriteLn(W);
+             (* now get the value *)
+             IF S.s = argStr0 THEN
+                Texts.Scan(S);
+                IF S.class = Texts.Name THEN
+                  Texts.WriteString(W, "value: "); Texts.WriteString (W, S.s); Texts.WriteLn(W); Texts.Append(Oberon.Log, W.buf);
+                ELSE
+                  Texts.WriteString(W, "string expected"); Texts.WriteLn(W);
+                  Texts.Append(Oberon.Log, W.buf);
+                  HALT(1);
+                END;
+             ELSIF S.s = argInt0 THEN
+                Texts.Scan(S);
+                IF S.class = Texts.Int THEN
+                  Texts.WriteString(W, "value: "); Texts.WriteInt (W, S.i, 0); Texts.WriteLn(W); Texts.Append(Oberon.Log, W.buf);
+                ELSE
+                  Texts.WriteString(W, "integer expected"); Texts.WriteLn(W);
+                  Texts.Append(Oberon.Log, W.buf);
+                  HALT(1);
+                END;
+             END;
+           ELSE
+             (* we were expecting characters after the '-' sign *)
+             Texts.WriteString(W, "key name expected"); Texts. WriteLn(W);
+             Texts.Append(Oberon.Log, W.buf);
+             HALT(1);
+           END;
+         END
+       ELSE
+         Texts.WriteString(W, "key option must start with '-' sign "); Texts.WriteLn(W);
+       HALT(1);
+       END; (* if got '-' *)
+    Oberon.Par.pos := Texts.Pos(S);
+    Texts.Append(Oberon.Log, W.buf)
+    END; (* while *)
+
+
+END partest.

examples/arguments/unixstyle_oberon_traditional/partest.Mod.ob2

@@ -0,0 +1,63 @@
+MODULE partest;
+
+IMPORT Oberon, Texts;
+
+CONST 
+  argStr0 = "str"; (* we only have two types of args, one string and one int *)
+  argInt0 = "int"; (* i. e. -str somestring -int somenumber *)
+
+VAR
+   W: Texts.Writer; (* for console output *)
+   S: Texts.Scanner; T: Texts.Text;
+BEGIN
+    Texts.OpenWriter(W);
+    Texts.WriteString(W, "hello, world, let's see which arguments do we get"); Texts.WriteLn(W);
+
+    (* open arguments scanner *)
+    Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos); 
+    
+    WHILE ~S.eot DO
+       Texts.Scan(S);
+
+       IF S.class = Texts.Char THEN (* do we get '-' sign ? *)
+         IF S.c = "-" THEN
+           Texts.Scan(S);
+           IF S.class = Texts.Name THEN (* we got the key *)
+             Texts.WriteString(W, "key: "); Texts.WriteString(W, S.s); Texts.WriteLn(W);
+             (* now get the value *)
+             IF S.s = argStr0 THEN
+                Texts.Scan(S);
+                IF S.class = Texts.Name THEN
+                  Texts.WriteString(W, "value: "); Texts.WriteString (W, S.s); Texts.WriteLn(W); Texts.Append(Oberon.Log, W.buf);
+                ELSE
+                  Texts.WriteString(W, "string expected"); Texts.WriteLn(W);
+                  Texts.Append(Oberon.Log, W.buf);
+                  HALT(1);
+                END;
+             ELSIF S.s = argInt0 THEN
+                Texts.Scan(S);
+                IF S.class = Texts.Int THEN
+                  Texts.WriteString(W, "value: "); Texts.WriteInt (W, S.i, 0); Texts.WriteLn(W); Texts.Append(Oberon.Log, W.buf);
+                ELSE
+                  Texts.WriteString(W, "integer expected"); Texts.WriteLn(W);
+                  Texts.Append(Oberon.Log, W.buf);
+                  HALT(1);
+                END;
+             END;
+           ELSE
+             (* we were expecting characters after the '-' sign *)
+             Texts.WriteString(W, "key name expected"); Texts. WriteLn(W);
+             Texts.Append(Oberon.Log, W.buf);
+             HALT(1);
+           END;
+         END
+       ELSE
+         Texts.WriteString(W, "key option must start with '-' sign "); Texts.WriteLn(W);
+       HALT(1);
+       END; (* if got '-' *)
+    Oberon.Par.pos := Texts.Pos(S);
+    Texts.Append(Oberon.Log, W.buf)
+    END; (* while *)
+
+
+END partest.

examples/arguments/unixstyle_oberon_traditional/readme.md

@@ -0,0 +1,47 @@
+
+example shows how to implement unix style arguments parsing by using traditional oberon functions from modules Texts and Oberon.
+
+compile
+=======
+
+```
+make
+```
+
+run
+===
+
+```
+make test
+```
+
+or type
+
+```
+./partest -str aaa -int 111
+```
+
+that should produce the following output
+
+```
+hello, world, let's see which arguments do we get
+key: str
+value: aaa
+key: int
+value: 111
+```
+
+```
+./partest -str 000 -int 111
+```
+
+the output will be
+
+```
+hello, world, let's see which arguments do we get
+key: str
+string expected
+Terminated by Halt(1).
+```
+
+that's all folks.