Do not require TAI64 left

diff --git a/go/cm/cmd/sigtool/main.go b/go/cm/cmd/sigtool/main.go
index 3ce84cb3b69682791b3fc510f65f7d77e0bd2b337ea7d04d673b894cbbe00273..7ceaff5bd4b8964a9568e558d594bef5267863ebc7df9d267bfd5531ce00870a 100644 (file)
--- a/go/cm/cmd/sigtool/main.go
+++ b/go/cm/cmd/sigtool/main.go
@@ -88,7 +88,7 @@ func main() {
                if t != types.Magic || decoder.Iter().Magic() != sign.SignedMagic {
                        log.Fatal("wrong magic")
                }
-               decoder = keks.NewDecoderFromReader(stdin, &keks.DecodeOpts{LeaveTAI64: true})
+               decoder = keks.NewDecoderFromReader(stdin, nil)
                var v any
                v, err = decoder.Decode()
                if err != nil {
@@ -130,7 +130,7 @@ func main() {
                                        log.Fatal(err)
                                }
                        }
-                       decoder = keks.NewDecoderFromReader(stdin, &keks.DecodeOpts{LeaveTAI64: true})
+                       decoder = keks.NewDecoderFromReader(stdin, nil)
                        v, err = decoder.Decode()
                        if err != nil {
                                log.Fatal(err)

diff --git a/go/cm/sign/pub.go b/go/cm/sign/pub.go
index b55060ee7ecf1f400281fe1dd61edfa33802f07b1e85e3a660911c5a6c4980ad..6df41dac0ec352d24c080ab83e764f1c649090672d67ac6a200c9076754d9288 100644 (file)
--- a/go/cm/sign/pub.go
+++ b/go/cm/sign/pub.go
@@ -63,7 +63,7 @@ func PubParse(data []byte) (signed *Signed, tail []byte, err error) {
                        return
                }
        }
-       d := keks.NewDecoderFromBytes(data, &keks.DecodeOpts{LeaveTAI64: true})
+       d := keks.NewDecoderFromBytes(data, nil)
        {
                var v any
                v, err = d.Decode()

diff --git a/go/cm/sign/signed.go b/go/cm/sign/signed.go
index 67968418b95916a04392254c88198d0eb2ae0272117ced4e14a5b4d79334039f..f24ced7d2cc77e91090f02158331bd8d9b0cfb200ed06d1805321bad66737091 100644 (file)
--- a/go/cm/sign/signed.go
+++ b/go/cm/sign/signed.go
@@ -75,7 +75,7 @@ func Parse(data []byte) (signed *Signed, tail []byte, err error) {
                        return
                }
        }
-       d := keks.NewDecoderFromBytes(data, &keks.DecodeOpts{LeaveTAI64: true})
+       d := keks.NewDecoderFromBytes(data, nil)
        {
                var v any
                v, err = d.Decode()

diff --git a/go/cmd/schema-validate/main.go b/go/cmd/schema-validate/main.go
index c201e871c7dac72438e262cf9f2bbd535b5fc5487fca8205a6ef5db36eedff22..1b25b8c6bfdb2e370ab1fc942981b2c1a6b23046809e0848dde5fb5395dd7a18 100644 (file)
--- a/go/cmd/schema-validate/main.go
+++ b/go/cmd/schema-validate/main.go
@@ -54,7 +54,7 @@ func main() {
                log.Fatal(err)
        }
 
-       d = keks.NewDecoderFromBytes(dataRaw, &keks.DecodeOpts{LeaveTAI64: true})
+       d = keks.NewDecoderFromBytes(dataRaw, nil)
        data, err := d.Decode()
        if err != nil {
                log.Fatal(err)

diff --git a/go/schema/check.go b/go/schema/check.go
index 6ea0df1ae9e53f0c356477ae44d7fbf39f2a74b2c84ce1974953aac8e42d3899..a147234c9ff45f696ef1ba8474eae4a4a7ceef83d1113c99d7559a7028315b48 100644 (file)
--- a/go/schema/check.go
+++ b/go/schema/check.go
@@ -19,6 +19,7 @@ import (
        "errors"
        "fmt"
        "slices"
+       "time"
 
        "go.cypherpunks.su/tai64n/v4"
 
@@ -171,6 +172,8 @@ func Check(schemaName string, schemas map[string][][]any, data any) error {
                                        typ = types.TAI64N
                                case *tai64n.TAI64NA:
                                        typ = types.TAI64NA
+                               case time.Time:
+                                       typ = types.TAI64N
                                case keks.Magic:
                                        typ = types.Magic
                                case []byte:
@@ -261,87 +264,87 @@ func Check(schemaName string, schemas map[string][][]any, data any) error {
                                return fmt.Errorf("%s: %d: %s: bad prec: %+v", schemaName, i, cmd, act[1])
                        }
                        for _, v := range vs {
+                               switch v := v.(type) {
+                               case *tai64n.TAI64:
+                               case *tai64n.TAI64N:
+                               case *tai64n.TAI64NA:
+                               case time.Time:
+                               default:
+                                       return fmt.Errorf("%s: %d: %s: unsupported data type: %T",
+                                               schemaName, i, cmd, v)
+                               }
                                switch prec {
                                case 0: // s
-                                       if _, ok = v.(*tai64n.TAI64); !ok {
-                                               return fmt.Errorf("%s: %d: %s: >TAI64", schemaName, i, cmd)
+                                       switch v := v.(type) {
+                                       case *tai64n.TAI64:
+                                       case time.Time:
+                                               if v.Nanosecond() != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >s", schemaName, i, cmd)
+                                               }
+                                       default:
+                                               return fmt.Errorf("%s: %d: %s: >s", schemaName, i, cmd)
                                        }
                                case 3: // ms
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       var tai *tai64n.TAI64N
-                                       tai, ok = v.(*tai64n.TAI64N)
-                                       if !ok {
-                                               return fmt.Errorf("%s: %d: %s: >TAI64N", schemaName, i, cmd)
-                                       }
-                                       d := be.Get(tai[8:])
-                                       if d%1000000 != 0 {
+                                       switch v := v.(type) {
+                                       case *tai64n.TAI64:
+                                       case *tai64n.TAI64N:
+                                               d := be.Get(v[8:])
+                                               if d%1000000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >ms", schemaName, i, cmd)
+                                               }
+                                       case time.Time:
+                                               if v.Nanosecond()%1000000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >ms", schemaName, i, cmd)
+                                               }
+                                       default:
                                                return fmt.Errorf("%s: %d: %s: >ms", schemaName, i, cmd)
                                        }
                                case 6: // µs
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       var tai *tai64n.TAI64N
-                                       tai, ok = v.(*tai64n.TAI64N)
-                                       if !ok {
-                                               return fmt.Errorf("%s: %d: %s: >TAI64N", schemaName, i, cmd)
-                                       }
-                                       d := be.Get(tai[8:])
-                                       if d%1000 != 0 {
+                                       switch v := v.(type) {
+                                       case *tai64n.TAI64:
+                                       case *tai64n.TAI64N:
+                                               d := be.Get(v[8:])
+                                               if d%1000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >µs", schemaName, i, cmd)
+                                               }
+                                       case time.Time:
+                                               if v.Nanosecond()%1000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >µs", schemaName, i, cmd)
+                                               }
+                                       default:
                                                return fmt.Errorf("%s: %d: %s: >µs", schemaName, i, cmd)
                                        }
                                case 9: // ns
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       if _, ok = v.(*tai64n.TAI64N); !ok {
-                                               return fmt.Errorf("%s: %d: %s: >TAI64N", schemaName, i, cmd)
+                                       switch v.(type) {
+                                       case *tai64n.TAI64:
+                                       case *tai64n.TAI64N:
+                                       case time.Time:
+                                       default:
+                                               return fmt.Errorf("%s: %d: %s: >ns", schemaName, i, cmd)
                                        }
                                case 12: // ps
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       if _, ok = v.(*tai64n.TAI64N); ok {
-                                               continue
-                                       }
-                                       var tai *tai64n.TAI64NA
-                                       tai, ok = v.(*tai64n.TAI64NA)
-                                       if !ok {
-                                               return fmt.Errorf("%s: %d: %s: non-TAI", schemaName, i, cmd)
-                                       }
-                                       d := be.Get(tai[12:])
-                                       if d%1000000 != 0 {
-                                               return fmt.Errorf("%s: %d: %s: >ps", schemaName, i, cmd)
+                                       switch v := v.(type) {
+                                       case time.Time:
+                                       case *tai64n.TAI64:
+                                       case *tai64n.TAI64N:
+                                       case *tai64n.TAI64NA:
+                                               d := be.Get(v[12:])
+                                               if d%1000000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >ps", schemaName, i, cmd)
+                                               }
                                        }
                                case 15: // fs
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       if _, ok = v.(*tai64n.TAI64N); ok {
-                                               continue
-                                       }
-                                       var tai *tai64n.TAI64NA
-                                       tai, ok = v.(*tai64n.TAI64NA)
-                                       if !ok {
-                                               return fmt.Errorf("%s: %d: %s: non-TAI", schemaName, i, cmd)
-                                       }
-                                       d := be.Get(tai[12:])
-                                       if d%1000 != 0 {
-                                               return fmt.Errorf("%s: %d: %s: >fs", schemaName, i, cmd)
+                                       switch v := v.(type) {
+                                       case time.Time:
+                                       case *tai64n.TAI64:
+                                       case *tai64n.TAI64N:
+                                       case *tai64n.TAI64NA:
+                                               d := be.Get(v[12:])
+                                               if d%1000 != 0 {
+                                                       return fmt.Errorf("%s: %d: %s: >fs", schemaName, i, cmd)
+                                               }
                                        }
                                case 18: // as
-                                       if _, ok = v.(*tai64n.TAI64); ok {
-                                               continue
-                                       }
-                                       if _, ok = v.(*tai64n.TAI64N); ok {
-                                               continue
-                                       }
-                                       if _, ok = v.(*tai64n.TAI64NA); ok {
-                                               continue
-                                       }
-                                       return fmt.Errorf("%s: %d: %s: non-TAI", schemaName, i, cmd)
                                default:
                                        return fmt.Errorf("%s: %d: %s: unknown value: %d",
                                                schemaName, i, cmd, prec)