gh-58: Add operator WARN.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -900,6 +900,8 @@
 
 - `INT: PRINT(INT|STR: a1, INT|STR: a2, ..., INT|STR: aN)` ; prints `INT`/`STR` arguments (side-effect), tensors are rejected; returns `INT` 0
 
+- `INT: WARN(INT|STR: a1, INT|STR: a2, ..., INT|STR: aN)` ; if the interpreter was started with the `-verbose` flag, prints `WARNING: ` followed by the arguments side-by-side using the same rendering rules as `PRINT`. Returns `INT` 1 when the warning was printed, otherwise `INT` 0. Tensors are rejected.
+
 - `INT: CL(STR: command)` - Executes the provided `command` string using the host shell and returns the subprocess exit code as an `INT`. The `command` argument MUST be a `STR`. On a failure to start the subprocess (for example if the system cannot invoke a shell), the interpreter raises a runtime error (rewrite: CL). The call records a `CL` event in the execution I/O log containing the command text and returned exit code, enabling deterministic logging and replay.
 
 - `INT: SHUSH()` - Suppresses forwarding of console output to the configured output sink. While shushed, calls that would normally print to the console (for example, `PRINT` and output captured from `CL`) do not forward their text to the interpreter's output sink, though the interpreter continues to record the corresponding I/O events in the execution log for deterministic replay. `INPUT` prompts are still forwarded even when shushed. The `RUN`  operator temporarily disables shushing for the duration of the executed source, so any output produced by code run via `RUN` is forwarded regardless of the current shush state. `SHUSH` takes no arguments and returns `INT` 0 on success.

src/builtins.c

@@ -4894,6 +4894,45 @@ static Value builtin_print(Interpreter* interp, Value* args, int argc, Expr** ar
     return value_int(0);
 }
 
+static Value builtin_warn(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
+    (void)arg_nodes; (void)env; (void)line; (void)col;
+    if (!interp) return value_int(0);
+
+    int forward = (interp->verbose && !interp->shushed);
+
+    if (forward) {
+        printf("WARNING: ");
+        for (int i = 0; i < argc; i++) {
+            if (i > 0) printf(" ");
+            switch (args[i].type) {
+                case VAL_INT: {
+                    char* s = int_to_base_prefixed_str(args[i].as.i, numeric_base_of(args[i]));
+                    printf("%s", s);
+                    free(s);
+                    break;
+                }
+                case VAL_FLT: {
+                    char* s = flt_to_base_prefixed_str(args[i].as.f, numeric_base_of(args[i]), args[i].num_base_nan);
+                    printf("%s", s);
+                    free(s);
+                    break;
+                }
+                case VAL_STR:
+                    printf("%s", args[i].as.s);
+                    break;
+                case VAL_FUNC:
+                    printf("<func %p>", (void*)args[i].as.func);
+                    break;
+                default:
+                    printf("<null>");
+                    break;
+            }
+        }
+        printf("\n");
+    }
+    return value_int(forward ? 1 : 0);
+}
+
 static Value builtin_input(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
     (void)arg_nodes; (void)env; (void)interp; (void)line; (void)col;
 
@@ -7250,6 +7289,7 @@ static BuiltinFunction builtins_table[] = {
 
     // I/O
     {"PRINT", 0, -1, builtin_print},
+    {"WARN", 0, -1, builtin_warn},
     {"INPUT", 0, 1, builtin_input},
     {"SHUSH", 0, 0, builtin_shush},
     {"UNSHUSH", 0, 0, builtin_unshush},