No need in hex output

diff --git a/c/lib/cm/default.schema.keks.do b/c/lib/cm/default.schema.keks.do
index 4134f0b79f06d182e307fa9340bb04281f17e2aa21f2764d8e0de7b54d4abe23..8decf8c8284d1992293b5b59785075f678eeff2467cb2a0fe2e3ef03e3b53395 100644 (file)
--- 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 8fbe5385663995f2958b66bd650de37a6538dcbb028d8292c99e85a5e7e9265a..8333e938217fe93756e483c4d59497f275eb30d0c85e693b156806af64d1cdf0 100644 (file)
--- 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 4062a09fc923e4f688bbc07304b77c5dd36f76fc055d27f2e12b005dcb5b689a..54c1138abbbe02e4d88dea95a2ae7932409fc40bf3aaeaffb64e503b25593d4a 100755 (executable)
--- 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 65f1eb1ead359231c96c96378cd5fbed3c2d2ddac632047cbebcf8c3132d7e85..7947d06441b293f2605f0232ad5361876eebfa167df9eaaae33eec477eab16a1 100755 (executable)
--- 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 341dc9b2556e38867dc076f24f657a6a793b76b9bf665e4da63fe748a169a652..7051bbb8c3c3181e2a8408c2f7784556162ae1c5506b33918d664eadde020681 100755 (executable)
--- 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 f7e829042b5d4a79bb8f7ab11345e3055ac8a635c3dd47787aacd474286882c6..7ff6823e891e9b3d5ab62af727da927b62457ce71711ab1b8448ea0aead5dad2 100755 (executable)
--- 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 ef2f584b88a8aac46557ffeadbfecb89ab5ce4612b12e60a150553db0b5ffc5d..195eea0aad481b8887be9c8c798cba723d5578562f9fa5f452b47194c9909667 100755 (executable)
--- 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 aed03aa71ce6914fd4aa684e29820155c618251503bc5e12fbb8eb8cf1baaa72..6ff031a48211a22d9cce73b43dae1ca82521672eca57da1eeadf4a8d46801c71 100755 (executable)
--- 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 680f46d505c6d370dafe57349dedfe300af66bf09e5a5a14130f8aad61bb1183..224701dc36cc8d8e256aec9a77128efd20af1b91268bd2e48702ab771d026639 100644 (file)
--- 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