From d6814788f2f9084c0252d87c370713aa70c5bcd37691379da90d168356af3c82 Mon Sep 17 00:00:00 2001
From: Sergey Matveev <stargrave@stargrave.org>
Date: Wed, 26 Nov 2025 19:14:20 +0300
Subject: [PATCH] No need in hex output

---
 c/lib/cm/default.schema.keks.do |   2 +-
 go/default.schema.keks.do       |   2 +-
 tcl/keks.tcl                    |   3 +-
 tcl/mk-fuzz-inputs              |   2 +-
 tcl/schema.t/generic.t          | 310 ++++++++++++--------------------
 tcl/schema.t/specs-our.t        |  32 ++--
 tcl/schema.t/specs-wheres.t     |  26 +--
 tcl/schema.tcl                  |   3 +-
 tcl/test-vector.tcl             |   3 +-
 9 files changed, 146 insertions(+), 237 deletions(-)

diff --git a/c/lib/cm/default.schema.keks.do b/c/lib/cm/default.schema.keks.do
index 4134f0b..8decf8c 100644
--- a/c/lib/cm/default.schema.keks.do
+++ b/c/lib/cm/default.schema.keks.do
@@ -4,4 +4,4 @@ cd ../../../tcl/schemas
     echo ../schema.tcl $n
     sed -n "s/^schema-include \(.*\)$/\1/p" <$n
 } | xargs redo-ifchange
-TCLLIBPATH=.. ../schema.tcl $n | xxd -r -p
+TCLLIBPATH=.. ../schema.tcl $n
diff --git a/go/default.schema.keks.do b/go/default.schema.keks.do
index 8fbe538..8333e93 100644
--- a/go/default.schema.keks.do
+++ b/go/default.schema.keks.do
@@ -4,4 +4,4 @@ cd ../tcl/schemas
     echo  ../schema.tcl $n
     sed -n "s/^schema-include \(.*\)$/\1/p" <$n
 } | xargs redo-ifchange
-TCLLIBPATH=.. ../schema.tcl $n | xxd -r -p
+TCLLIBPATH=.. ../schema.tcl $n
diff --git a/tcl/keks.tcl b/tcl/keks.tcl
index 4062a09..54c1138 100755
--- a/tcl/keks.tcl
+++ b/tcl/keks.tcl
@@ -356,5 +356,6 @@ if {[info exists argv0] && ([file tail [info script]] eq [file tail $argv0])} {
     set buf ""
     set in [read stdin]
     eval $in
-    puts [binary encode hex $buf]
+    fconfigure stdout -translation binary
+    puts -nonewline $buf
 }
diff --git a/tcl/mk-fuzz-inputs b/tcl/mk-fuzz-inputs
index 65f1eb1..7947d06 100755
--- a/tcl/mk-fuzz-inputs
+++ b/tcl/mk-fuzz-inputs
@@ -1,7 +1,7 @@
 #!/bin/sh -e
 
 dump() {
-    echo "$@" | keks.tcl | xxd -r -p
+    echo "$@" | keks.tcl
 }
 
 dump 'BIN ""' >bin-empty
diff --git a/tcl/schema.t/generic.t b/tcl/schema.t/generic.t
index 341dc9b..7051bbb 100755
--- a/tcl/schema.t/generic.t
+++ b/tcl/schema.t/generic.t
@@ -9,23 +9,20 @@ export TCLLIBPATH=$root
 cat >schema.tcl <<EOF
 e {{field . {str bin}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR ok
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "type ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 BIN ok
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "type ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 INT 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "type !ok" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -33,23 +30,20 @@ test_expect_success "type !ok" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {set}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar NIL baz NIL}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "set ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar NIL baz {INT 123}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "set !ok" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 SET {foo bar baz}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "set macro" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -57,38 +51,34 @@ test_expect_success "set macro" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {map}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {INT 123} bar {STR hello}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map various" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {map} {of type int}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {INT 123} bar {STR hello}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !of int" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {INT 123} bar {INT 234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map of int" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 v {{field . {int}}}
 e {{field . {map} {of v}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {INT 123} bar {INT 234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map of int schema" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -96,38 +86,34 @@ test_expect_success "map of int schema" "$SCHEMA_VALIDATE schema.keks e <data.ke
 cat >schema.tcl <<EOF
 e {{field . {list}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {STR hello}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list various" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {list} {of type int}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {STR hello}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list !of int" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {INT 234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list of int" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 v {{field . {int}}}
 e {{field . {list} {of v}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {INT 234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list of int schema" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -141,17 +127,15 @@ e {
     {field 1 {with str}}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {STR foo}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list take ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 50} {STR foo}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list take bad range" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -160,17 +144,15 @@ cat >schema.tcl <<EOF
 v {{field . {int}}}
 e {{field . {with v}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR foo
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "!only schema" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 INT -123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "only schema" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -181,17 +163,15 @@ e {
     {field bar {int}}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {bar {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map exists" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL baz {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !exists" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
@@ -200,23 +180,20 @@ e {
     {field bar {int} optional}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map optional" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL baz {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map optional !exists" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar NIL}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map optional bad type" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
@@ -225,17 +202,15 @@ e {
     {field bar {} !exists}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !!exists" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL baz {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !exists" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
@@ -245,25 +220,22 @@ e {
     {field baz {int} optional}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !len=~ without optional" "
     ! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo NIL bar {INT 0} baz {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !len=~ with optional" "
     ! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {bar {INT 0} baz {INT 0}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !len=~" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -271,33 +243,29 @@ test_expect_success "map !len=~" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {int} >0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 INT 0
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int !>0" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 INT 1
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {int} >-1000}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 INT -1000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int !>-999" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 INT -999
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int >-999" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -305,17 +273,15 @@ test_expect_success "int >-999" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {str} >0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR ""
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str !>0" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 STR "a"
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -323,17 +289,15 @@ test_expect_success "str >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {list} >0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list !>0" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {NIL}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -341,17 +305,15 @@ test_expect_success "list >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {map} >0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map !>0" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 SET {a}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -359,41 +321,37 @@ test_expect_success "map >0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {map} len=0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {list} len=0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {str} len=0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR ""
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {int} len=0}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 INT 0
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -401,41 +359,37 @@ test_expect_success "int len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {map} len=3}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 SET {a b c}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "map len=3" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {list} len=3}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 LIST {NIL NIL NIL}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "list len=3" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {str} len=3}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR foo
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str len=3" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {int} len=3}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 INT 3
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "int len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -443,43 +397,38 @@ test_expect_success "int len=0" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {str} =hello}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR hello
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str =" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 STR foobar
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str !=" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {str} =[encoding convertto utf-8 привет]}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 STR привет
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "str cyrillic =" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {hexlet} =[binary decode hex "0e875e3fd38549eb87b4be42d641c367"]}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 HEXLET 0e875e3f-d385-49eb-87b4-be42d641c367
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "hexlet =" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 HEXLET 0e875e3f-d385-49eb-87b4-be42d641c368
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "hexlet !=" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
@@ -488,17 +437,15 @@ e {
     {field foo {magic} =world}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {MAGIC world}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "magic =" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {foo {MAGIC мир}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "magic !=" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -510,23 +457,20 @@ e {
     {field fpr {with fpr} optional}
 }
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 MAP {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr !exists" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {fpr {STR 1234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr bad type" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {fpr {BIN 1234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -534,27 +478,24 @@ test_expect_success "fpr ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {tai}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 ok" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 [expr 0x586846A4]
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !utc" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} utc}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 [expr 0x586846A4]
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !!utc" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
@@ -562,122 +503,107 @@ test_expect_success "tai64 !!utc" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=s}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=s" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=s" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=ms}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123000000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=ms" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=ms" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=us}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=us" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=us" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=ns}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=ns" "$SCHEMA_VALIDATE schema.keks e <data.keks"
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=ns" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=ns" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=ps}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123000000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=ps" "$SCHEMA_VALIDATE schema.keks e <data.keks"
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=ps" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=ps" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai} prec=fs}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123000
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=fs" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 !prec=fs" "! $SCHEMA_VALIDATE schema.keks e <data.keks"
 
 cat >schema.tcl <<EOF
 e {{field . {tai}}}
 EOF
-$root/schema.tcl schema.tcl | xxd -r -p >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/schema.tcl schema.tcl >schema.keks
+$root/keks.tcl >data.keks <<EOF
 TAI64 123 123 123
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "tai64 prec=fs" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 ########################################################################
 
-$root/keks.tcl >schema.keks.hex <<EOF
+$root/keks.tcl >schema.keks <<EOF
 MAGIC schema
 MAP {e {LIST {
     {LIST {{STR T} {STR L}}}
@@ -687,11 +613,9 @@ MAP {e {LIST {
     {LIST {{STR <} {INT 300}}}
 }}}
 EOF
-xxd -r -p <schema.keks.hex >schema.keks
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{INT 123} {INT 234}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "manual int ranges" "$SCHEMA_VALIDATE schema.keks e <data.keks"
 
 test_done
diff --git a/tcl/schema.t/specs-our.t b/tcl/schema.t/specs-our.t
index f7e8290..7ff6823 100755
--- a/tcl/schema.t/specs-our.t
+++ b/tcl/schema.t/specs-our.t
@@ -17,9 +17,9 @@ our {
     {field comment {str} optional}
 }
 EOF
-$root/schema.tcl our.schema.tcl | xxd -r -p >our.schema.keks
+$root/schema.tcl our.schema.tcl >our.schema.keks
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
@@ -27,20 +27,18 @@ MAP {
     comment {STR привет}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "ok" "$SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
     fpr {BIN [binary decode hex [string repeat "AB" 32]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "no comment" "$SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
@@ -48,75 +46,67 @@ MAP {
     comment {STR ""}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "empty comment" "$SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
     fpr {BIN [binary decode hex [string repeat "AB" 33]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr longer" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
     fpr {BIN [binary decode hex [string repeat "AB" 31]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr shorter" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN ""}
     fpr {BIN [binary decode hex [string repeat "AB" 32]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "v empty" "$SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR ""}
     v {STR whatever}
     fpr {BIN [binary decode hex [string repeat "AB" 32]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "a empty" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {INT 123}
     v {BIN [binary decode hex "DEADBEEF"]}
     fpr {BIN [binary decode hex [string repeat "AB" 32]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "a bad type" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     a {STR some-ai}
     v {BIN [binary decode hex "DEADBEEF"]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "fpr no" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 MAP {
     v {BIN [binary decode hex "DEADBEEF"]}
     fpr {BIN [binary decode hex [string repeat "AB" 32]]}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "a no" "! $SCHEMA_VALIDATE our.schema.keks our <data.keks"
 
 test_done
diff --git a/tcl/schema.t/specs-wheres.t b/tcl/schema.t/specs-wheres.t
index ef2f584..195eea0 100755
--- a/tcl/schema.t/specs-wheres.t
+++ b/tcl/schema.t/specs-wheres.t
@@ -16,64 +16,56 @@ where {
 }
 wheres {{field . {list} {of where} >0}}
 EOF
-$root/schema.tcl wheres.schema.tcl | xxd -r -p >wheres.schema.keks
+$root/schema.tcl wheres.schema.tcl >wheres.schema.keks
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "wheres empty" "! $SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{LIST {}}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "where empty" "! $SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{LIST {{INT 45} {INT 180}}}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "ok" "$SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{LIST {{INT -45} {INT 180}}}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "lat negative" "$SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {{LIST {{INT 45} {INT -180}}}}
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "lon negative" "$SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {
     {LIST {{INT 45} {INT 180}}}
     {LIST {{INT -91} {INT 180}}}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "oob lat" "! $SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {
     {LIST {{INT 45} {INT 180}}}
     {LIST {{INT 90} {INT -181}}}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "oob lon" "! $SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
-$root/keks.tcl >data.keks.hex <<EOF
+$root/keks.tcl >data.keks <<EOF
 LIST {
     {LIST {{INT 45} {INT 180}}}
     {LIST {{STR 0} {INT 123}}}
     {LIST {{INT 12}}}
 }
 EOF
-xxd -r -p <data.keks.hex >data.keks
 test_expect_success "lon bad len" "! $SCHEMA_VALIDATE wheres.schema.keks wheres <data.keks"
 
 test_done
diff --git a/tcl/schema.tcl b/tcl/schema.tcl
index aed03aa..6ff031a 100755
--- a/tcl/schema.tcl
+++ b/tcl/schema.tcl
@@ -177,5 +177,6 @@ if {[info exists argv0] && ([file tail [info script]] eq [file tail $argv0])} {
     set buf ""
     MAGIC schema
     KEKS::Schema::do $_schema
-    puts [binary encode hex $buf]
+    fconfigure stdout -translation binary
+    puts -nonewline $buf
 }
diff --git a/tcl/test-vector.tcl b/tcl/test-vector.tcl
index 680f46d..224701d 100644
--- a/tcl/test-vector.tcl
+++ b/tcl/test-vector.tcl
@@ -77,4 +77,5 @@ MAP {
     ip {HEXLET 2001:0db8:85a3:08d3:1319:8a2e:0370:7348}
 }
 
-puts [binary encode hex $buf]
+fconfigure stdout -translation binary
+puts -nonewline $buf
-- 
2.52.0