From 3b68b867b111d3b6302f8b488a4e6a8b7645f0c5 Mon Sep 17 00:00:00 2001 From: Matthew Butterick Date: Tue, 21 May 2019 20:31:34 -0700 Subject: [PATCH] 64-bit ints --- xenomorph/xenomorph/int.rkt | 5 +++ .../xenomorph/scribblings/xenomorph.scrbl | 37 +++++++++++++------ 2 files changed, 31 insertions(+), 11 deletions(-) diff --git a/xenomorph/xenomorph/int.rkt b/xenomorph/xenomorph/int.rkt index 2d8f4623..311587b4 100644 --- a/xenomorph/xenomorph/int.rkt +++ b/xenomorph/xenomorph/int.rkt @@ -108,6 +108,7 @@ https://github.com/mbutterick/restructure/blob/master/src/Number.coffee (define int16 (x:int 2)) (define int24 (x:int 3)) (define int32 (x:int 4)) +(define int64 (x:int 8)) (define uint8 (x:int 1 #:signed #f)) (define uint16 (x:int 2 #:signed #f)) (define uint24 (x:int 3 #:signed #f)) @@ -117,18 +118,22 @@ https://github.com/mbutterick/restructure/blob/master/src/Number.coffee (define int16be (x:int 2 #:endian 'be)) (define int24be (x:int 3 #:endian 'be)) (define int32be (x:int 4 #:endian 'be)) +(define int64be (x:int 8 #:endian 'be)) (define uint8be (x:int 1 #:signed #f #:endian 'be)) (define uint16be (x:int 2 #:signed #f #:endian 'be)) (define uint24be (x:int 3 #:signed #f #:endian 'be)) (define uint32be (x:int 4 #:signed #f #:endian 'be)) +(define uint64be (x:int 8 #:signed #f #:endian 'be)) (define int8le (x:int 1 #:endian 'le)) (define int16le (x:int 2 #:endian 'le)) (define int24le (x:int 3 #:endian 'le)) (define int32le (x:int 4 #:endian 'le)) +(define int64le (x:int 8 #:endian 'le)) (define uint8le (x:int 1 #:signed #f #:endian 'le)) (define uint16le (x:int 2 #:signed #f #:endian 'le)) (define uint24le (x:int 3 #:signed #f #:endian 'le)) (define uint32le (x:int 4 #:signed #f #:endian 'le)) +(define uint64le (x:int 8 #:signed #f #:endian 'le)) (module+ test (require rackunit "base.rkt") diff --git a/xenomorph/xenomorph/scribblings/xenomorph.scrbl b/xenomorph/xenomorph/scribblings/xenomorph.scrbl index f40d6736..0c5db7f0 100644 --- a/xenomorph/xenomorph/scribblings/xenomorph.scrbl +++ b/xenomorph/xenomorph/scribblings/xenomorph.scrbl @@ -454,10 +454,12 @@ Generate an instance of @racket[x:int%] (or a subclass of @racket[x:int%]) with @defthing[int16 x:int?] @defthing[int24 x:int?] @defthing[int32 x:int?] +@defthing[int64 x:int?] @defthing[uint8 x:int?] @defthing[uint16 x:int?] @defthing[uint24 x:int?] -@defthing[uint32 x:int?]) +@defthing[uint32 x:int?] +@defthing[uint64 x:int?]) ]{ The common integer types, using @racket[system-endian] endianness. The @racket[u] prefix indicates unsigned. The numerical suffix indicates bit length. @@ -468,31 +470,33 @@ Use these carefully, however. Binary formats are usually defined using one endia (encode int16 1 #f) (encode int24 1 #f) (encode int32 1 #f) +(encode int64 1 #f) (encode int8 -128 #f) (encode int16 -128 #f) (encode int24 -128 #f) (encode int32 -128 #f) +(encode int64 -128 #f) (encode uint8 1 #f) (encode uint16 1 #f) (encode uint24 1 #f) (encode uint32 1 #f) +(encode uint64 1 #f) (code:comment @#,t{negative numbers cannot be encoded as unsigned ints, of course}) (encode uint8 -128 #f) (encode uint16 -128 #f) (encode uint24 -128 #f) (encode uint32 -128 #f) +(encode uint64 -128 #f) (decode int8 #"1" #f) (decode int16 #"10" #f) (decode int24 #"100" #f) (decode int32 #"1000" #f) -(decode int8 #"1" #f) -(decode int16 #"10" #f) -(decode int24 #"100" #f) -(decode int32 #"1000" #f) +(decode int64 #"10000000" #f) (decode uint8 #"1" #f) (decode uint16 #"10" #f) (decode uint24 #"100" #f) (decode uint32 #"1000" #f) +(decode uint64 #"10000000" #f) ] } @@ -503,10 +507,12 @@ Use these carefully, however. Binary formats are usually defined using one endia @defthing[int16be x:int?] @defthing[int24be x:int?] @defthing[int32be x:int?] +@defthing[int64be x:int?] @defthing[uint8be x:int?] @defthing[uint16be x:int?] @defthing[uint24be x:int?] -@defthing[uint32be x:int?]) +@defthing[uint32be x:int?] +@defthing[uint64be x:int?]) ]{ Big-endian versions of the common integer types. The @racket[u] prefix indicates unsigned. The numerical suffix indicates bit length. @racket[int8be] and @racket[uint8be] are included for consistency, but as one-byte types, they are not affected by endianness. @@ -516,26 +522,32 @@ Big-endian versions of the common integer types. The @racket[u] prefix indicates (encode int16be 1 #f) (encode int24be 1 #f) (encode int32be 1 #f) +(encode int64be 1 #f) (encode int8be -128 #f) (encode int16be -128 #f) (encode int24be -128 #f) (encode int32be -128 #f) +(encode int64be -128 #f) (encode uint8be 1 #f) (encode uint16be 1 #f) (encode uint24be 1 #f) (encode uint32be 1 #f) +(encode uint64be 1 #f) (decode int8be #"1" #f) (decode int16be #"10" #f) (decode int24be #"100" #f) (decode int32be #"1000" #f) +(decode int64be #"10000000" #f) (decode int8be #"1" #f) (decode int16be #"10" #f) (decode int24be #"100" #f) (decode int32be #"1000" #f) +(decode int64be #"10000000" #f) (decode uint8be #"1" #f) (decode uint16be #"10" #f) (decode uint24be #"100" #f) (decode uint32be #"1000" #f) +(decode uint64be #"10000000" #f) ] } @@ -545,10 +557,12 @@ Big-endian versions of the common integer types. The @racket[u] prefix indicates @defthing[int16le x:int?] @defthing[int24le x:int?] @defthing[int32le x:int?] +@defthing[int64le x:int?] @defthing[uint8le x:int?] @defthing[uint16le x:int?] @defthing[uint24le x:int?] -@defthing[uint32le x:int?]) +@defthing[uint32le x:int?] +@defthing[uint64le x:int?]) ]{ Little-endian versions of the common integer types. The @racket[u] prefix indicates unsigned. The numerical suffix indicates bit length. @racket[int8le] and @racket[uint8le] are included for consistency, but as one-byte types, they are not affected by endianness. @@ -557,26 +571,27 @@ Little-endian versions of the common integer types. The @racket[u] prefix indica (encode int16le 1 #f) (encode int24le 1 #f) (encode int32le 1 #f) +(encode int64le 1 #f) (encode int8le -128 #f) (encode int16le -128 #f) (encode int24le -128 #f) (encode int32le -128 #f) +(encode int64le -128 #f) (encode uint8le 1 #f) (encode uint16le 1 #f) (encode uint24le 1 #f) (encode uint32le 1 #f) +(encode uint64le 1 #f) (decode int8le #"1" #f) (decode int16le #"10" #f) (decode int24le #"100" #f) (decode int32le #"1000" #f) -(decode int8le #"1" #f) -(decode int16le #"10" #f) -(decode int24le #"100" #f) -(decode int32le #"1000" #f) +(decode int64le #"10000000" #f) (decode uint8le #"1" #f) (decode uint16le #"10" #f) (decode uint24le #"100" #f) (decode uint32le #"1000" #f) +(decode uint64le #"10000000" #f) ] }