tcl: fix Phase 7d oo tests using ::name-with-hyphens

Tcl tokenizer treats $::g-name as $::g + literal -name, so the var
lookup fails. Renamed test vars to ::gname / ::nval (no hyphens).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

hosts/ocaml/lib/sx_primitives.ml

@@ -528,6 +528,183 @@ let () =
     | [Rational (_, d)] -> Integer d
     | [Integer _]       -> Integer 1
     | _ -> raise (Eval_error "denominator: expected rational or integer"));
+  (* printf-spec: apply one Tcl/printf format spec to one arg.
+     spec is like "%5.2f", "%-10s", "%x", "%c", "%d". Always starts with %
+     and ends with the conversion char.  Supports d i u x X o c s f e g.
+     Coerces arg to the right type per conversion. *)
+  register "printf-spec" (fun args ->
+    let spec_str, arg = match args with
+      | [String s; v] -> (s, v)
+      | _ -> raise (Eval_error "printf-spec: (spec arg)")
+    in
+    let n = String.length spec_str in
+    if n < 2 || spec_str.[0] <> '%' then
+      raise (Eval_error ("printf-spec: invalid spec " ^ spec_str));
+    let type_char = spec_str.[n - 1] in
+    let to_int v = match v with
+      | Integer i -> i
+      | Number f -> int_of_float f
+      | String s ->
+        let s = String.trim s in
+        (try int_of_string s
+         with _ ->
+           try int_of_float (float_of_string s)
+           with _ -> 0)
+      | Bool true -> 1 | Bool false -> 0
+      | _ -> 0
+    in
+    let to_float v = match v with
+      | Number f -> f
+      | Integer i -> float_of_int i
+      | String s ->
+        let s = String.trim s in
+        (try float_of_string s with _ -> 0.0)
+      | _ -> 0.0
+    in
+    let to_string v = match v with
+      | String s -> s
+      | Integer i -> string_of_int i
+      | Number f -> Sx_types.format_number f
+      | Bool true -> "1" | Bool false -> "0"
+      | Nil -> ""
+      | _ -> Sx_types.inspect v
+    in
+    try
+      match type_char with
+      | 'd' | 'i' ->
+        let fmt = Scanf.format_from_string spec_str "%d" in
+        String (Printf.sprintf fmt (to_int arg))
+      | 'u' ->
+        let fmt = Scanf.format_from_string spec_str "%u" in
+        String (Printf.sprintf fmt (to_int arg))
+      | 'x' ->
+        let fmt = Scanf.format_from_string spec_str "%x" in
+        String (Printf.sprintf fmt (to_int arg))
+      | 'X' ->
+        let fmt = Scanf.format_from_string spec_str "%X" in
+        String (Printf.sprintf fmt (to_int arg))
+      | 'o' ->
+        let fmt = Scanf.format_from_string spec_str "%o" in
+        String (Printf.sprintf fmt (to_int arg))
+      | 'c' ->
+        let n_val = to_int arg in
+        let body = String.sub spec_str 0 (n - 1) in
+        let fmt = Scanf.format_from_string (body ^ "s") "%s" in
+        String (Printf.sprintf fmt (String.make 1 (Char.chr (n_val land 0xff))))
+      | 's' ->
+        let fmt = Scanf.format_from_string spec_str "%s" in
+        String (Printf.sprintf fmt (to_string arg))
+      | 'f' ->
+        let fmt = Scanf.format_from_string spec_str "%f" in
+        String (Printf.sprintf fmt (to_float arg))
+      | 'e' ->
+        let fmt = Scanf.format_from_string spec_str "%e" in
+        String (Printf.sprintf fmt (to_float arg))
+      | 'E' ->
+        let fmt = Scanf.format_from_string spec_str "%E" in
+        String (Printf.sprintf fmt (to_float arg))
+      | 'g' ->
+        let fmt = Scanf.format_from_string spec_str "%g" in
+        String (Printf.sprintf fmt (to_float arg))
+      | 'G' ->
+        let fmt = Scanf.format_from_string spec_str "%G" in
+        String (Printf.sprintf fmt (to_float arg))
+      | _ -> raise (Eval_error ("printf-spec: unsupported conversion " ^ String.make 1 type_char))
+    with
+    | Eval_error _ as e -> raise e
+    | _ -> raise (Eval_error ("printf-spec: invalid format " ^ spec_str)));
+
+  (* scan-spec: apply one Tcl/scanf format spec to a string.
+     Returns (consumed-count . parsed-value), or nil on failure. *)
+  register "scan-spec" (fun args ->
+    let spec_str, str = match args with
+      | [String s; String input] -> (s, input)
+      | _ -> raise (Eval_error "scan-spec: (spec input)")
+    in
+    let n = String.length spec_str in
+    if n < 2 || spec_str.[0] <> '%' then
+      raise (Eval_error ("scan-spec: invalid spec " ^ spec_str));
+    let type_char = spec_str.[n - 1] in
+    let len = String.length str in
+    (* skip leading whitespace for non-%c/%s conversions *)
+    let i = ref 0 in
+    if type_char <> 'c' then
+      while !i < len && (str.[!i] = ' ' || str.[!i] = '\t' || str.[!i] = '\n') do incr i done;
+    let start = !i in
+    try
+      match type_char with
+      | 'd' | 'i' ->
+        let j = ref !i in
+        if !j < len && (str.[!j] = '-' || str.[!j] = '+') then incr j;
+        while !j < len && str.[!j] >= '0' && str.[!j] <= '9' do incr j done;
+        if !j > start && (str.[start] >= '0' && str.[start] <= '9'
+                         || (!j > start + 1 && (str.[start] = '-' || str.[start] = '+'))) then
+          let n_val = int_of_string (String.sub str start (!j - start)) in
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (Integer n_val);
+          Hashtbl.replace d "consumed" (Integer !j);
+          Dict d
+        else Nil
+      | 'x' | 'X' ->
+        let j = ref !i in
+        while !j < len &&
+              ((str.[!j] >= '0' && str.[!j] <= '9') ||
+               (str.[!j] >= 'a' && str.[!j] <= 'f') ||
+               (str.[!j] >= 'A' && str.[!j] <= 'F')) do incr j done;
+        if !j > start then
+          let n_val = int_of_string ("0x" ^ String.sub str start (!j - start)) in
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (Integer n_val);
+          Hashtbl.replace d "consumed" (Integer !j);
+          Dict d
+        else Nil
+      | 'o' ->
+        let j = ref !i in
+        while !j < len && str.[!j] >= '0' && str.[!j] <= '7' do incr j done;
+        if !j > start then
+          let n_val = int_of_string ("0o" ^ String.sub str start (!j - start)) in
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (Integer n_val);
+          Hashtbl.replace d "consumed" (Integer !j);
+          Dict d
+        else Nil
+      | 'f' | 'e' | 'g' ->
+        let j = ref !i in
+        if !j < len && (str.[!j] = '-' || str.[!j] = '+') then incr j;
+        while !j < len && ((str.[!j] >= '0' && str.[!j] <= '9') || str.[!j] = '.') do incr j done;
+        if !j < len && (str.[!j] = 'e' || str.[!j] = 'E') then begin
+          incr j;
+          if !j < len && (str.[!j] = '-' || str.[!j] = '+') then incr j;
+          while !j < len && str.[!j] >= '0' && str.[!j] <= '9' do incr j done
+        end;
+        if !j > start then
+          let f_val = float_of_string (String.sub str start (!j - start)) in
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (Number f_val);
+          Hashtbl.replace d "consumed" (Integer !j);
+          Dict d
+        else Nil
+      | 's' ->
+        let j = ref !i in
+        while !j < len && str.[!j] <> ' ' && str.[!j] <> '\t' && str.[!j] <> '\n' do incr j done;
+        if !j > start then
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (String (String.sub str start (!j - start)));
+          Hashtbl.replace d "consumed" (Integer !j);
+          Dict d
+        else Nil
+      | 'c' ->
+        if !i < len then
+          let d = Hashtbl.create 2 in
+          Hashtbl.replace d "value" (Integer (Char.code str.[!i]));
+          Hashtbl.replace d "consumed" (Integer (!i + 1));
+          Dict d
+        else Nil
+      | _ -> raise (Eval_error ("scan-spec: unsupported conversion " ^ String.make 1 type_char))
+    with
+    | Eval_error _ as e -> raise e
+    | _ -> Nil);
+
   register "parse-int" (fun args ->
     let parse_leading_int s =
       let len = String.length s in
@@ -3366,6 +3543,204 @@ let () =
       Nil
     | _ -> raise (Eval_error "channel-set-blocking!: (channel bool)"));
 
+  (* === Exec === run an external process; capture stdout *)
+  register "exec-process" (fun args ->
+    let items = match args with
+      | [List xs] | [ListRef { contents = xs }] -> xs
+      | _ -> raise (Eval_error "exec-process: (cmd-list)")
+    in
+    let argv = Array.of_list (List.map (function
+      | String s -> s
+      | v -> Sx_types.inspect v
+    ) items) in
+    if Array.length argv = 0 then raise (Eval_error "exec: empty command");
+    let (out_r, out_w) = Unix.pipe () in
+    let (err_r, err_w) = Unix.pipe () in
+    let pid =
+      try Unix.create_process argv.(0) argv Unix.stdin out_w err_w
+      with Unix.Unix_error (e, _, _) ->
+        Unix.close out_r; Unix.close out_w;
+        Unix.close err_r; Unix.close err_w;
+        raise (Eval_error ("exec: " ^ Unix.error_message e))
+    in
+    Unix.close out_w;
+    Unix.close err_w;
+    let buf = Buffer.create 256 in
+    let errbuf = Buffer.create 64 in
+    let chunk = Bytes.create 4096 in
+    let read_all fd target =
+      try
+        let stop = ref false in
+        while not !stop do
+          let n = Unix.read fd chunk 0 (Bytes.length chunk) in
+          if n = 0 then stop := true
+          else Buffer.add_subbytes target chunk 0 n
+        done
+      with _ -> ()
+    in
+    read_all out_r buf;
+    read_all err_r errbuf;
+    Unix.close out_r;
+    Unix.close err_r;
+    let (_, status) = Unix.waitpid [] pid in
+    let exit_code = match status with
+      | Unix.WEXITED n -> n
+      | Unix.WSIGNALED _ | Unix.WSTOPPED _ -> 1
+    in
+    let s = Buffer.contents buf in
+    let trimmed =
+      if String.length s > 0 && s.[String.length s - 1] = '\n'
+      then String.sub s 0 (String.length s - 1) else s
+    in
+    if exit_code <> 0 then
+      raise (Eval_error ("exec: child exited " ^ string_of_int exit_code
+                         ^ (if Buffer.length errbuf > 0
+                            then ": " ^ Buffer.contents errbuf
+                            else "")))
+    else String trimmed);
+
+  (* exec-pipeline: takes a list of words like Tcl `exec` would receive.
+     Recognizes `|` as a stage separator and `> file`, `>> file`, `< file`,
+     `2>@1` (stderr→stdout), `2> file`. Returns trimmed stdout of the last
+     stage; raises Eval_error if the last stage exits non-zero. *)
+  register "exec-pipeline" (fun args ->
+    let items = match args with
+      | [List xs] | [ListRef { contents = xs }] -> xs
+      | _ -> raise (Eval_error "exec-pipeline: (word-list)")
+    in
+    let words = List.map (function
+      | String s -> s
+      | v -> Sx_types.inspect v
+    ) items in
+    if words = [] then raise (Eval_error "exec: empty command");
+    let split_stages ws =
+      let rec loop acc cur = function
+        | [] -> List.rev (List.rev cur :: acc)
+        | "|" :: rest -> loop (List.rev cur :: acc) [] rest
+        | w :: rest -> loop acc (w :: cur) rest
+      in
+      loop [] [] ws
+    in
+    let extract_redirs ws =
+      let in_path = ref None in
+      let out_path = ref None in
+      let out_append = ref false in
+      let err_path = ref None in
+      let merge_err = ref false in
+      let cleaned = ref [] in
+      let rec loop = function
+        | [] -> ()
+        | "<" :: p :: rest -> in_path := Some p; loop rest
+        | ">" :: p :: rest -> out_path := Some p; out_append := false; loop rest
+        | ">>" :: p :: rest -> out_path := Some p; out_append := true; loop rest
+        | "2>@1" :: rest -> merge_err := true; loop rest
+        | "2>" :: p :: rest -> err_path := Some p; loop rest
+        | w :: rest -> cleaned := w :: !cleaned; loop rest
+      in
+      loop ws;
+      (List.rev !cleaned, !in_path, !out_path, !out_append, !err_path, !merge_err)
+    in
+    let stages = List.map extract_redirs (split_stages words) in
+    if stages = [] then raise (Eval_error "exec: no stages");
+    let n = List.length stages in
+    let pipes = Array.init (max 0 (n - 1)) (fun _ -> Unix.pipe ()) in
+    let (final_r, final_w) = Unix.pipe () in
+    let (errstash_r, errstash_w) = Unix.pipe () in
+    let pids = ref [] in
+    let close_safe fd = try Unix.close fd with _ -> () in
+    let open_in_redir = function
+      | None -> Unix.stdin
+      | Some path ->
+        (try Unix.openfile path [Unix.O_RDONLY] 0o644
+         with Unix.Unix_error (e, _, _) ->
+           raise (Eval_error ("exec: open <" ^ path ^ ": " ^ Unix.error_message e)))
+    in
+    let open_out_redir path append =
+      let flags = Unix.O_WRONLY :: Unix.O_CREAT :: (if append then [Unix.O_APPEND] else [Unix.O_TRUNC]) in
+      try Unix.openfile path flags 0o644
+      with Unix.Unix_error (e, _, _) ->
+        raise (Eval_error ("exec: open >" ^ path ^ ": " ^ Unix.error_message e))
+    in
+    let stages_arr = Array.of_list stages in
+    (try
+      Array.iteri (fun i (cleaned, ip, op, app, ep, merge) ->
+        if cleaned = [] then raise (Eval_error "exec: empty stage in pipeline");
+        let argv = Array.of_list cleaned in
+        let stdin_fd =
+          if i = 0 then open_in_redir ip
+          else fst pipes.(i - 1)
+        in
+        let stdout_fd =
+          if i = n - 1 then
+            (match op with
+             | None -> final_w
+             | Some path -> open_out_redir path app)
+          else snd pipes.(i)
+        in
+        let stderr_fd =
+          if merge then stdout_fd
+          else (match ep with
+                | None -> if i = n - 1 then errstash_w else Unix.stderr
+                | Some path -> open_out_redir path false)
+        in
+        let pid =
+          try Unix.create_process argv.(0) argv stdin_fd stdout_fd stderr_fd
+          with Unix.Unix_error (e, _, _) ->
+            raise (Eval_error ("exec: " ^ argv.(0) ^ ": " ^ Unix.error_message e))
+        in
+        pids := pid :: !pids;
+        if i > 0 then close_safe (fst pipes.(i - 1));
+        if i < n - 1 then close_safe (snd pipes.(i));
+        if i = 0 && ip <> None then close_safe stdin_fd;
+        if i = n - 1 && op <> None then close_safe stdout_fd;
+        if not merge && ep <> None then close_safe stderr_fd
+      ) stages_arr
+    with e ->
+      close_safe final_r; close_safe final_w;
+      close_safe errstash_r; close_safe errstash_w;
+      Array.iter (fun (a,b) -> close_safe a; close_safe b) pipes;
+      raise e);
+    close_safe final_w;
+    close_safe errstash_w;
+    let buf = Buffer.create 256 in
+    let errbuf = Buffer.create 64 in
+    let chunk = Bytes.create 4096 in
+    let read_all fd target =
+      try
+        let stop = ref false in
+        while not !stop do
+          let r = Unix.read fd chunk 0 (Bytes.length chunk) in
+          if r = 0 then stop := true
+          else Buffer.add_subbytes target chunk 0 r
+        done
+      with _ -> ()
+    in
+    read_all final_r buf;
+    read_all errstash_r errbuf;
+    close_safe final_r;
+    close_safe errstash_r;
+    let exit_codes = List.rev_map (fun pid ->
+      let (_, st) = Unix.waitpid [] pid in
+      match st with
+      | Unix.WEXITED c -> c
+      | _ -> 1
+    ) !pids in
+    let final_code = match List.rev exit_codes with
+      | [] -> 0
+      | last :: _ -> last
+    in
+    let s = Buffer.contents buf in
+    let trimmed =
+      if String.length s > 0 && s.[String.length s - 1] = '\n'
+      then String.sub s 0 (String.length s - 1) else s
+    in
+    if final_code <> 0 then
+      raise (Eval_error ("exec: pipeline last stage exited " ^ string_of_int final_code
+                         ^ (if Buffer.length errbuf > 0
+                            then ": " ^ Buffer.contents errbuf
+                            else "")))
+    else String trimmed);
+
   (* === Sockets === wrapping Unix.socket/connect/bind/listen/accept *)
   let resolve_inet_addr host =
     if host = "" || host = "0.0.0.0" then Unix.inet_addr_any

lib/tcl/test.sh

@@ -57,7 +57,7 @@ cat > "$TMPFILE" << EPOCHS
 (eval "tcl-test-summary")
 EPOCHS
 
-OUTPUT=$(timeout 2400 "$SX_SERVER" < "$TMPFILE" 2>&1)
+OUTPUT=$(timeout 7200 "$SX_SERVER" < "$TMPFILE" 2>&1)
 [ "$VERBOSE" = "-v" ] && echo "$OUTPUT"
 
 # Extract summary line from epoch 11 output

lib/tcl/tests/idioms.sx

@@ -415,6 +415,268 @@
         :result)
       "")
 
+    ; 60-63. Phase 6a namespace :: prefix
+    (ok "ns-set-from-proc-reaches-global"
+      (get
+        (run
+          "proc f {x} { set ::g $x }\nf hello\nset ::g")
+        :result)
+      "hello")
+
+    (ok "ns-read-from-proc"
+      (get
+        (run
+          "set ::v 42\nproc f {} { return $::v }\nf")
+        :result)
+      "42")
+
+    (ok "ns-incr-via-prefix"
+      (get
+        (run
+          "set ::n 5\nproc bump {} { incr ::n }\nbump\nbump\nset ::n")
+        :result)
+      "7")
+
+    (ok "ns-different-from-local"
+      (get
+        (run
+          "set x outer\nproc f {} { set x inner; set ::x global; return $x }\nf")
+        :result)
+      "inner")
+
+    ; 64-69. Phase 6b list ops (lassign, lrepeat, lset, lmap)
+    (ok "lassign-three"
+      (get (run "lassign {a b c d e} x y z\nlist $x $y $z") :result)
+      "a b c")
+
+    (ok "lassign-leftover"
+      (get (run "lassign {1 2 3 4 5} a b") :result)
+      "3 4 5")
+
+    (ok "lrepeat-basic"
+      (get (run "lrepeat 3 a") :result)
+      "a a a")
+
+    (ok "lrepeat-multi"
+      (get (run "lrepeat 2 x y") :result)
+      "x y x y")
+
+    (ok "lset-replaces"
+      (get (run "set L {a b c d}\nlset L 2 ZZ\nset L") :result)
+      "a b ZZ d")
+
+    (ok "lmap-square"
+      (get (run "lmap n {1 2 3 4} {expr {$n * $n}}") :result)
+      "1 4 9 16")
+
+    ; 70-72. Phase 6c dict additions (lappend, remove, filter)
+    (ok "dict-lappend-extends"
+      (get (run "set d {tags {a b}}\ndict lappend d tags c d\nset d") :result)
+      "tags {a b c d}")
+
+    (ok "dict-remove"
+      (get (run "dict remove {a 1 b 2 c 3} b") :result)
+      "a 1 c 3")
+
+    (ok "dict-filter-key"
+      (get (run "dict filter {alpha 1 beta 2 gamma 3} key a*") :result)
+      "alpha 1")
+
+    ; 73-79. Phase 6d format and scan
+    (ok "format-int-padded"
+      (get (run "format {%05d} 42") :result)
+      "00042")
+
+    (ok "format-float-precision"
+      (get (run "format {%.2f} 3.14159") :result)
+      "3.14")
+
+    (ok "format-hex"
+      (get (run "format {%x} 255") :result)
+      "ff")
+
+    (ok "format-char"
+      (get (run "format {%c} 65") :result)
+      "A")
+
+    (ok "format-string-left"
+      (get (run "format {%-5s|} hi") :result)
+      "hi   |")
+
+    (ok "scan-two-ints"
+      (get (run "scan {12 34} {%d %d} a b\nlist $a $b") :result)
+      "12 34")
+
+    (ok "scan-count"
+      (get (run "scan {hello 42} {%s %d}") :result)
+      "hello 42")
+
+    ; 80-82. Phase 6e exec
+    (ok "exec-echo"
+      (get (run "exec echo hello world") :result)
+      "hello world")
+
+    (ok "exec-printf-no-newline"
+      (get (run "exec /bin/printf x") :result)
+      "x")
+
+    (ok "exec-with-args"
+      (get (run "exec /bin/echo -n test") :result)
+      "test")
+
+    ; 83-87. Phase 7a try/trap with varlist
+    (ok "try-trap-prefix-match"
+      (get
+        (run
+          "try {throw {ARITH DIVZERO} divide-by-zero} trap {ARITH} {res} {set caught $res}")
+        :result)
+      "divide-by-zero")
+
+    (ok "try-trap-full-pattern"
+      (get
+        (run
+          "try {throw {FOO BAR} bad} trap {FOO BAR} {res} {return matched-foo-bar}")
+        :result)
+      "matched-foo-bar")
+
+    (ok "try-on-error-opts"
+      (get
+        (run
+          "try {error oops} on error {res opts} {dict get $opts -code}")
+        :result)
+      "1")
+
+    (ok "try-trap-no-match-falls-through"
+      (get
+        (run
+          "set caught notrun\ncatch {try {throw {NOPE} bad} trap {OTHER} {r} {set caught matched}}\nset caught")
+        :result)
+      "notrun")
+
+    (ok "try-trap-then-on-error"
+      (get
+        (run
+          "try {error generic} trap {SPECIFIC} {r} {return trap-fired} on error {r} {return on-error-fired}")
+        :result)
+      "on-error-fired")
+
+    ; 88-92. Phase 7b exec pipelines + redirection
+    (ok "exec-pipeline-tr"
+      (get (run "exec echo hello world | tr a-z A-Z") :result)
+      "HELLO WORLD")
+
+    (ok "exec-pipeline-wc"
+      (get (run "exec /bin/echo abc | wc -c") :result)
+      "4")
+
+    (ok "exec-redirect-stdout"
+      (get
+        (run
+          "set f /tmp/tcl-7b-out.txt\nexec echo hello > $f\nset r [exec cat $f]\nfile delete $f\nreturn $r")
+        :result)
+      "hello")
+
+    (ok "exec-redirect-stdin"
+      (get
+        (run
+          "set f /tmp/tcl-7b-in.txt\nset c [open $f w]\nputs -nonewline $c hi\nclose $c\nset r [exec cat < $f]\nfile delete $f\nreturn $r")
+        :result)
+      "hi")
+
+    (ok "exec-pipeline-three-stages"
+      (get (run "exec echo {alpha beta gamma} | tr { } \\n | wc -l") :result)
+      "3")
+
+    ; 93-99. Phase 7c string command audit
+    (ok "string-equal"
+      (get (run "string equal hello hello") :result)
+      "1")
+
+    (ok "string-equal-nocase"
+      (get (run "string equal -nocase HELLO hello") :result)
+      "1")
+
+    (ok "string-totitle"
+      (get (run "string totitle hello") :result)
+      "Hello")
+
+    (ok "string-reverse"
+      (get (run "string reverse hello") :result)
+      "olleh")
+
+    (ok "string-replace"
+      (get (run "string replace hello 1 3 ZZZ") :result)
+      "hZZZo")
+
+    (ok "string-is-xdigit-yes"
+      (get (run "string is xdigit ff00aa") :result)
+      "1")
+
+    (ok "string-is-true-yes"
+      (get (run "string is true yes") :result)
+      "1")
+
+    ; 100-105. Phase 7e regexp anchoring/boundary audit
+    (ok "regexp-anchor-start"
+      (get (run "regexp {^hello} hello-world") :result)
+      "1")
+
+    (ok "regexp-anchor-end"
+      (get (run "regexp {world$} hello-world") :result)
+      "1")
+
+    (ok "regexp-word-boundary"
+      (get (run "regexp {\\bword\\b} \"the word here\"") :result)
+      "1")
+
+    (ok "regexp-nocase"
+      (get (run "regexp -nocase {HELLO} hello") :result)
+      "1")
+
+    (ok "regexp-capture-var"
+      (get (run "regexp {[0-9]+} abc123def captured\nset captured") :result)
+      "123")
+
+    (ok "regsub-all"
+      (get (run "regsub -all {[0-9]+} a1b22c333 X") :result)
+      "aXbXcX")
+
+    ; 106-110. Phase 7d TclOO basics
+    (ok "oo-class-method"
+      (get
+        (run
+          "oo::class create C {\nmethod get {} { return 42 }\n}\nset c [C new]\n$c get")
+        :result)
+      "42")
+
+    (ok "oo-constructor"
+      (get
+        (run
+          "oo::class create G {\nconstructor {n} { set ::gname $n }\nmethod hello {} { return [string cat \"hi \" $::gname] }\n}\nset g [G new World]\n$g hello")
+        :result)
+      "hi World")
+
+    (ok "oo-inheritance-overridden"
+      (get
+        (run
+          "oo::class create Animal {\nmethod sound {} { return generic }\n}\noo::class create Dog {\nsuperclass Animal\nmethod sound {} { return woof }\n}\nset d [Dog new]\n$d sound")
+        :result)
+      "woof")
+
+    (ok "oo-inheritance-inherited"
+      (get
+        (run
+          "oo::class create Animal {\nmethod sound {} { return generic }\n}\noo::class create Cat {\nsuperclass Animal\n}\nset c [Cat new]\n$c sound")
+        :result)
+      "generic")
+
+    (ok "oo-multiple-instances"
+      (get
+        (run
+          "oo::class create N {\nconstructor {x} { set ::nval $x }\nmethod get {} { return $::nval }\n}\nset a [N new 1]\nset b [N new 99]\n$b get")
+        :result)
+      "99")
+
     (dict
       "passed"
       tcl-idiom-pass

lib/tcl/tokenizer.sx

@@ -167,7 +167,9 @@
                       (begin
                         (when (= (cur) "}") (advance! 1))
                         {:type "var" :name name}))))))
-            ((tcl-ident-start? (cur))
+            ((or
+                (tcl-ident-start? (cur))
+                (and (= (cur) ":") (= (char-at 1) ":")))
               (let ((start pos))
                 (begin
                   (scan-ns-name!)