HTTP Client POC

.github/copilot-instructions.md

@@ -7,8 +7,9 @@
   - Open array parameters are allowed as procedure parameters only.
   - Function return values **must be handled**.
   - Return is only allowed as the last statement in a procedure. Use a `result` variable for returning values.
-  - No early returns are allowed.
-  - Forward declarations for procedures are not allowed (only for pointers).
+  - Early returns are not valid in Oberon-07. EXIT is not a valid oberon keyword.
+  - Procedure definitions must precede their calls.
+  - Forward declarations for procedures are not valid in Oberon-07 (only for pointers).
   - A situation requiring mutual recursion can be handled by using procedure types to make indirect calls.
   - The last statement before an `END` or an `ELSE` **must not end with a semicolon**.
   - For bitwise operations, use our own implementation from `Bitwise.mod`.
@@ -17,11 +18,17 @@
   - You cannot substitute a procedure into SYSTEM.VAL(), use a local variable in such cases.
   - Oberon-07 reintroduced FOR loops, so **use them instead of WHILE loops where appropriate**.
   - There is no enumeration type in oberon 07. use INTEGER. 
+  - Local procedures cannot be passed as procedure variables. 
+  - Oberon does not support escape sequences, 
+    Instead of escape sequences use a combination of a rider-based DStrings write operations 
+    and Chars.CR and similar constants from `Chars.mod`.
 - **Best Practices**
   - Functions and procedures should be clear, concise, and well-structured.
   - Use helper functions to avoid code duplication.
   - Use modules to encapsulate functionality. Use opaque pointers to expose necessary types. Hide implementation details.
   - Export only what is necessary; keep the interface clean.
+  - Local procedures (procedures defined inside other procedures) can promote cleaner code organization by grouping related code together. 
+  - Local procedures can make deeply nested code. Use with care.
   - Use meaningful names for modules, procedures, and variables.
   - Use PascalCase for module names, constants and procedures and camelCase for variables.
 
@@ -48,31 +55,3 @@
 - Internal procedures documentation comment lines start with `(*` and end with `*)`, so they are not included in the API documentation.
 - The header should contain a copyright notice for the 3 clause BSD license, the module name, a brief description, and the author.
 - Be conservative and factual in documentation statements, do not exaggerate.
-
-## Creating C wrappers
-
-1. Create a file named M.obn with the the exported declarations.
-   Proper Procedures should have empty bodies to satisfy syntax requirements.
-   Example: `PROCEDURE MyProc; BEGIN END MyProc;` 
-   Function procedures should have a dummy return value to satisfy syntax requirements.
-   Example: `PROCEDURE MyFunc() : BOOLEAN; BEGIN RETURN TRUE END MyFunc;` 
-
-2. Create a file named MTest.obn which imports M (and preferably  write
-    unit tests for M)
-3. Build MTest with the command
-        obnc MTest.obn
-4. Copy the generated file .obnc/M.c to the current directory. In M.c,
-    delete the generator comment on the first line.
-5. Copy the generated file .obnc/M.h to the current directory.
-6. Implement M.c. Update M.h as needed.
-
-### Notes on C Wrappers
-
-1. The initialization function M__Init is called each time a client
-  module imports M. Its statements should therefore be  guarded  with an
-  initialization flag to make sure they are executed only once.
-2. To use pointers to C structures, declare INTEGERS in oberon, 
-   OBNC_INTEGER is 32-bit, Oberon has no way to represent 64-bit integers. 
-   Therefore you have to update the generated code: the relevant casts should be revised, 
-   and uintptr_t should be used instead of OBNC_INTEGER.
-   This works as long as there is no direct access to the structure fields from Oberon code.

.github/instructions/CreateOberonCWrapper.instructions.md

@@ -0,0 +1,31 @@
+---
+applyTo: '*.c;*.h;*.obn'
+---
+
+## Creating C wrappers
+
+1. Create a file named M.obn with the the exported declarations.
+   Proper Procedures should have empty bodies to satisfy syntax requirements.
+   Example: `PROCEDURE MyProc; BEGIN END MyProc;` 
+   Function procedures should have a dummy return value to satisfy syntax requirements.
+   Example: `PROCEDURE MyFunc() : BOOLEAN; BEGIN RETURN TRUE END MyFunc;` 
+
+2. Create a file named MTest.obn which imports M (and preferably  write
+    unit tests for M)
+3. Build MTest with the command
+        obnc MTest.obn
+4. Copy the generated file .obnc/M.c to the current directory. In M.c,
+    delete the generator comment on the first line.
+5. Copy the generated file .obnc/M.h to the current directory.
+6. Implement M.c. Update M.h as needed.
+
+### Notes on C Wrappers
+
+1. The initialization function M__Init is called each time a client
+  module imports M. Its statements should therefore be  guarded  with an
+  initialization flag to make sure they are executed only once.
+2. To use pointers to C structures, declare INTEGERS in oberon, 
+   OBNC_INTEGER is 32-bit, Oberon has no way to represent 64-bit integers. 
+   Therefore you have to update the generated code: the relevant casts should be revised, 
+   and uintptr_t should be used instead of OBNC_INTEGER.
+   This works as long as there is no direct access to the structure fields from Oberon code.

.github/instructions/NewOberonModuleCreationOBNC.instructions.md

@@ -0,0 +1,58 @@
+---
+applyTo: '*.Mod'
+---
+## Creating Oberon Modules with OBNC compiler
+
+Create a minimal stub with the opaque type and empty procedures.
+Every procedure should have a body, even if it is empty, to satisfy the syntax requirements of the Oberon-07 language.
+Create a minimal test module that imports the new module. 
+The makefile discovers the module and you can compile it with 
+
+`make MyModuleTest`
+
+### Minimal Test Example:
+
+```Oberon-07
+(** MyModuleTest.Mod - Tests for MyModule.Mod.
+
+Copyright (C) 2025 Artemis Project Contributors
+
+Released under The 3-Clause BSD License.
+*)
+MODULE MyModuleTest;
+IMPORT MyModule, Tests;
+
+VAR
+  ts: Tests.TestSet;
+
+PROCEDURE TestExample(): BOOLEAN;
+VAR
+  pass: BOOLEAN; (* Other variable declarations*)
+BEGIN
+  pass := TRUE;
+
+  (* Perform the test *)
+
+  Tests.ExpectedBool(TRUE, MyModule.MyFunc(), "MyModule.MyFunc() pass", pass)
+
+  RETURN pass
+END TestExample;
+
+(* Other testcases as needed. *)
+
+BEGIN
+  Tests.Init(ts, "Example Tests");
+  Tests.Add(ts, TestExample);
+
+  ASSERT(Tests.Run(ts));
+END MyModuleTest.
+
+```
+
+### Best practices 
+
+- Use modules to encapsulate functionality. Use opaque pointers to expose necessary types. Hide implementation details.
+- Export only what is necessary; keep the interface clean.
+- Local procedures (procedures defined inside other procedures) can promote cleaner code organization by grouping related code together. 
+- Local procedures can make deeply nested code. Use with care.
+

DStrings.Mod

@@ -524,7 +524,7 @@ BEGIN
     c := Get(r); INC(l);
   END;
   IF l > 0 THEN
-    Delete(source, 0, (l - 1));
+    Delete(source, 0, l);
   END;
 END TrimLeft;
 
@@ -860,9 +860,9 @@ END WriteString;
 PROCEDURE WriteDString*(VAR r : Rider; source : String);
   VAR c : CHAR; s : Rider;
 BEGIN
-  Set(s, source, 0); c := Get(r);
+  Set(s, source, 0); c := Get(s);
   WHILE c # 0X DO
-    Put(s, c); c := Get(r);
+    Put(r, c); c := Get(s);
   END;
 END WriteDString;
 
@@ -936,7 +936,7 @@ BEGIN
 END WriteSet;
 
 (**WriteFixed writes a renumber with a fixed number of decimal places
-   to a string. E.g. write out dollar ammounts as 1.32 rather then E
+   to a string. E.g. write out dollar amounts as 1.32 rather then E
    notation *)
 PROCEDURE WriteFixed*(VAR r : Rider; value : REAL; n : INTEGER);
   VAR tmp : ARRAY 64 OF CHAR; ok : BOOLEAN;

DStringsTest.Mod

@@ -519,6 +519,17 @@ BEGIN test := TRUE;
   RETURN test
 END TestWriteProcs;
 
+PROCEDURE TestTrimSpace() : BOOLEAN;
+VAR test: BOOLEAN; s, expected: DStrings.String;
+BEGIN
+  test := TRUE;
+  DStrings.Init("   hello world   ", s);
+  DStrings.Init("hello world", expected);
+  DStrings.TrimSpace(s);
+  ExpectedDString(expected, s, "TrimSpace('   hello world   ')", test);
+  RETURN test
+END TestTrimSpace;
+
 BEGIN
   T.Init(ts, "Test DStrings");
   T.Add(ts,TestInit);
@@ -535,6 +546,7 @@ BEGIN
   T.Add(ts,TestReplace);
   T.Add(ts,TestCap);
   T.Add(ts,TestStartsWith);
+  T.Add(ts,TestTrimSpace);
 
   (* Test the Files base procedures *)
   T.Add(ts,TestReadProcs);

Dictionary.Mod

@@ -34,16 +34,14 @@ VAR
     intKey: CollectionKeys.IntegerKeyPtr;
     key: INTEGER;
     value: Collections.ItemPtr;
-    dictState: DictVisitorState;
     result: BOOLEAN;
 BEGIN
     pair := item(HashMap.KeyValuePairPtr);
     keyPtr := HashMap.PairKey(pair);
     intKey := keyPtr(CollectionKeys.IntegerKeyPtr);
     key := intKey.value;
     value := HashMap.PairValue(pair);
-    dictState := state(DictVisitorState);
-    result := dictState.intVisitor(key, value, state);
+    result := state(DictVisitorState).intVisitor(key, value, state);
     RETURN result
 END IntKeyAdapter;
 
@@ -54,15 +52,13 @@ VAR
     keyPtr: CollectionKeys.KeyPtr;
     strKey: CollectionKeys.StringKeyPtr;
     value: Collections.ItemPtr;
-    dictState: DictVisitorState;
     result: BOOLEAN;
 BEGIN
     pair := item(HashMap.KeyValuePairPtr);
     keyPtr := HashMap.PairKey(pair);
     strKey := keyPtr(CollectionKeys.StringKeyPtr);
     value := HashMap.PairValue(pair);
-    dictState := state(DictVisitorState);
-    result := dictState.stringVisitor(strKey.value, value, state);
+    result := state(DictVisitorState).stringVisitor(strKey.value, value, state);
     RETURN result
 END StringKeyAdapter;