Datasets:

microsoft

/

FStarDataSet-V2

like 0

FStar.ST.fst

FStar.ST.modifies_none

val modifies_none : h0: FStar.Monotonic.Heap.heap -> h1: FStar.Monotonic.Heap.heap -> Prims.logical

let modifies_none (h0:heap) (h1:heap) = modifies !{} h0 h1

(* Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, and Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.ST open FStar.TSet open FStar.Heap open FStar.Preorder module W = FStar.Monotonic.Witnessed (***** Global ST (GST) effect with put, get, witness, and recall *****) new_effect GST = STATE_h heap let gst_pre = st_pre_h heap let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre let gst_post (a:Type) = st_post_h heap a let gst_wp (a:Type) = st_wp_h heap a unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h) sub_effect DIV ~> GST = lift_div_gst let heap_rel (h1:heap) (h2:heap) = forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==> (h2 `contains` r /\ rel (sel h1 r) (sel h2 r)) assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0) assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1) type heap_predicate = heap -> Type0 let stable (p:heap_predicate) = forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2 [@@"opaque_to_smt"] let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0)) assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0)) val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p}) (q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)}) :Lemma (ensures (witnessed q)) let lemma_functoriality p q = reveal_opaque (`%witnessed) witnessed; W.lemma_witnessed_weakening heap_rel p q (***** ST effect *****) let st_pre = gst_pre let st_post' = gst_post' let st_post = gst_post let st_wp = gst_wp new_effect STATE = GST unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp sub_effect GST ~> STATE = lift_gst_state effect State (a:Type) (wp:st_wp a) = STATE a wp effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) = STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1)) effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True) let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)} let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h) = gst_recall (contains_pred r) let alloc (#a:Type) (#rel:preorder a) (init:a) :ST (mref a rel) (fun h -> True) (fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init) = let h0 = gst_get () in let r, h1 = alloc rel h0 init false in gst_put h1; gst_witness (contains_pred r); r let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h) = let h0 = gst_get () in gst_recall (contains_pred r); Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r; sel_tot h0 r let write (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v) = let h0 = gst_get () in gst_recall (contains_pred r); let h1 = upd_tot h0 r v in Heap.lemma_distinct_addrs_distinct_preorders (); Heap.lemma_distinct_addrs_distinct_mm (); Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v; gst_put h1 let get (u:unit) :ST heap (fun h -> True) (fun h0 h h1 -> h0==h1 /\ h==h1) = gst_get () let op_Bang (#a:Type) (#rel:preorder a) (r:mref a rel) : STATE a (fun p h -> p (sel h r) h) = read #a #rel r let op_Colon_Equals (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v) = write #a #rel r v type ref (a:Type0) = mref a (trivial_preorder a)

h0: FStar.Monotonic.Heap.heap -> h1: FStar.Monotonic.Heap.heap -> Prims.logical

Prims.Tot

let modifies_none (h0 h1: heap) =

modifies FStar.Set.empty h0 h1

FStar.ST.fst

FStar.ST.write

val write (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v)

val write (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v)

let write (#a:Type) (#rel:preorder a) (r:mref a rel) (v:a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v) = let h0 = gst_get () in gst_recall (contains_pred r); let h1 = upd_tot h0 r v in Heap.lemma_distinct_addrs_distinct_preorders (); Heap.lemma_distinct_addrs_distinct_mm (); Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v; gst_put h1

(* Copyright 2008-2014 Nikhil Swamy, Aseem Rastogi, and Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module FStar.ST open FStar.TSet open FStar.Heap open FStar.Preorder module W = FStar.Monotonic.Witnessed (***** Global ST (GST) effect with put, get, witness, and recall *****) new_effect GST = STATE_h heap let gst_pre = st_pre_h heap let gst_post' (a:Type) (pre:Type) = st_post_h' heap a pre let gst_post (a:Type) = st_post_h heap a let gst_wp (a:Type) = st_wp_h heap a unfold let lift_div_gst (a:Type) (wp:pure_wp a) (p:gst_post a) (h:heap) = wp (fun a -> p a h) sub_effect DIV ~> GST = lift_div_gst let heap_rel (h1:heap) (h2:heap) = forall (a:Type0) (rel:preorder a) (r:mref a rel). h1 `contains` r ==> (h2 `contains` r /\ rel (sel h1 r) (sel h2 r)) assume val gst_get: unit -> GST heap (fun p h0 -> p h0 h0) assume val gst_put: h1:heap -> GST unit (fun p h0 -> heap_rel h0 h1 /\ p () h1) type heap_predicate = heap -> Type0 let stable (p:heap_predicate) = forall (h1:heap) (h2:heap). (p h1 /\ heap_rel h1 h2) ==> p h2 [@@"opaque_to_smt"] let witnessed (p:heap_predicate{stable p}) : Type0 = W.witnessed heap_rel p assume val gst_witness: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ p h0 /\ (witnessed p ==> post () h0)) assume val gst_recall: p:heap_predicate -> GST unit (fun post h0 -> stable p /\ witnessed p /\ (p h0 ==> post () h0)) val lemma_functoriality (p:heap_predicate{stable p /\ witnessed p}) (q:heap_predicate{stable q /\ (forall (h:heap). p h ==> q h)}) :Lemma (ensures (witnessed q)) let lemma_functoriality p q = reveal_opaque (`%witnessed) witnessed; W.lemma_witnessed_weakening heap_rel p q (***** ST effect *****) let st_pre = gst_pre let st_post' = gst_post' let st_post = gst_post let st_wp = gst_wp new_effect STATE = GST unfold let lift_gst_state (a:Type) (wp:gst_wp a) = wp sub_effect GST ~> STATE = lift_gst_state effect State (a:Type) (wp:st_wp a) = STATE a wp effect ST (a:Type) (pre:st_pre) (post: (h:heap -> Tot (st_post' a (pre h)))) = STATE a (fun (p:st_post a) (h:heap) -> pre h /\ (forall a h1. post h a h1 ==> p a h1)) effect St (a:Type) = ST a (fun h -> True) (fun h0 r h1 -> True) let contains_pred (#a:Type0) (#rel:preorder a) (r:mref a rel) = fun h -> h `contains` r type mref (a:Type0) (rel:preorder a) = r:Heap.mref a rel{is_mm r = false /\ witnessed (contains_pred r)} let recall (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE unit (fun p h -> Heap.contains h r ==> p () h) = gst_recall (contains_pred r) let alloc (#a:Type) (#rel:preorder a) (init:a) :ST (mref a rel) (fun h -> True) (fun h0 r h1 -> fresh r h0 h1 /\ modifies Set.empty h0 h1 /\ sel h1 r == init) = let h0 = gst_get () in let r, h1 = alloc rel h0 init false in gst_put h1; gst_witness (contains_pred r); r let read (#a:Type) (#rel:preorder a) (r:mref a rel) :STATE a (fun p h -> p (sel h r) h) = let h0 = gst_get () in gst_recall (contains_pred r); Heap.lemma_sel_equals_sel_tot_for_contained_refs h0 r; sel_tot h0 r

r: FStar.ST.mref a rel -> v: a -> FStar.ST.ST Prims.unit

FStar.ST.ST

let write (#a: Type) (#rel: preorder a) (r: mref a rel) (v: a) : ST unit (fun h -> rel (sel h r) v) (fun h0 x h1 -> rel (sel h0 r) v /\ h0 `contains` r /\ modifies (Set.singleton (addr_of r)) h0 h1 /\ equal_dom h0 h1 /\ sel h1 r == v) =

let h0 = gst_get () in gst_recall (contains_pred r); let h1 = upd_tot h0 r v in Heap.lemma_distinct_addrs_distinct_preorders (); Heap.lemma_distinct_addrs_distinct_mm (); Heap.lemma_upd_equals_upd_tot_for_contained_refs h0 r v; gst_put h1

Spec.Agile.CTR.fst

Spec.Agile.CTR.counter_mode

val counter_mode: a:cipher_alg -> k:key a -> n:nonce a -> plain:bytes { length plain <= max_size_t } -> Tot (cipher:bytes { length cipher = length plain })

val counter_mode: a:cipher_alg -> k:key a -> n:nonce a -> plain:bytes { length plain <= max_size_t } -> Tot (cipher:bytes { length cipher = length plain })

let counter_mode a k n plain = let stream = ctr_stream a k n (length plain) in map2 ( ^. ) (plain <: lbytes (length plain)) (stream <: lbytes (length plain))

module Spec.Agile.CTR open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.ByteSequence open Spec.Agile.Cipher #reset-options "--z3rlimit 20 --max_fuel 0 --max_ifuel 1" // So that clients don't need to open both modules include Spec.Agile.Cipher val counter_mode: a:cipher_alg -> k:key a -> n:nonce a -> plain:bytes { length plain <= max_size_t } ->

a: Spec.Agile.Cipher.cipher_alg -> k: Spec.Agile.Cipher.key a -> n: Spec.Agile.Cipher.nonce a -> plain: Lib.ByteSequence.bytes{Lib.Sequence.length plain <= Lib.IntTypes.max_size_t} -> cipher: Lib.ByteSequence.bytes{Lib.Sequence.length cipher = Lib.Sequence.length plain}

Prims.Tot

let counter_mode a k n plain =

let stream = ctr_stream a k n (length plain) in map2 ( ^. ) (plain <: lbytes (length plain)) (stream <: lbytes (length plain))

SigeltOpts.fst

SigeltOpts.sp1

val sp1 : Prims.unit

let sp1 = assert (List.length [1] == 1)

module SigeltOpts open FStar.Tactics.V2 #set-options "--max_fuel 0"

Prims.unit

Prims.Tot

let sp1 =

assert (List.length [1] == 1)

SigeltOpts.fst

SigeltOpts.tau

val tau: Prims.unit -> Tac decls

val tau: Prims.unit -> Tac decls

let tau () : Tac decls = match lookup_typ (top_env ()) ["SigeltOpts"; "sp1"] with | None -> fail "1" | Some se -> match sigelt_opts se with | None -> fail "2" | Some opts -> let lb = { lb_fv = pack_fv ["SigeltOpts"; "blah"]; lb_us = []; lb_typ = (`_); lb_def = (`(assert (List.length [2] == 1))) } in let se : sigelt = pack_sigelt (Sg_Let {isrec=false;lbs=[lb]}) in let se = add_check_with opts se in [se]

module SigeltOpts open FStar.Tactics.V2 #set-options "--max_fuel 0" #push-options "--max_fuel 2 --record_options" let sp1 = assert (List.length [1] == 1) #pop-options (* Fails without fuel *) [@@expect_failure] let sp2 = assert (List.length [1] == 1)

_: Prims.unit -> FStar.Tactics.Effect.Tac FStar.Stubs.Reflection.Types.decls

FStar.Tactics.Effect.Tac

let tau () : Tac decls =

match lookup_typ (top_env ()) ["SigeltOpts"; "sp1"] with | None -> fail "1" | Some se -> match sigelt_opts se with | None -> fail "2" | Some opts -> let lb = { lb_fv = pack_fv ["SigeltOpts"; "blah"]; lb_us = []; lb_typ = (`_); lb_def = (`(assert (List.length [2] == 1))) } in let se:sigelt = pack_sigelt (Sg_Let ({ isrec = false; lbs = [lb] })) in let se = add_check_with opts se in [se]

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parse

val parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input))

val parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input))

let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b))

p: LowParse.Spec.Base.bare_parser t -> input: LowParse.Bytes.bytes -> Prims.GTot (FStar.Pervasives.Native.option (t * LowParse.Spec.Base.consumed_length input))

Prims.GTot

let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) =

p input

LowParse.Spec.Base.fsti

LowParse.Spec.Base.injective

val injective (#t: Type) (p: bare_parser t) : GTot Type0

val injective (#t: Type) (p: bare_parser t) : GTot Type0

let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = ()

p: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let injective (#t: Type) (p: bare_parser t) : GTot Type0 =

forall (b1: bytes) (b2: bytes). {:pattern (injective_precond p b1 b2)\/(injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_update_st

val poly1305_update_st : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_update_st (s:field_spec) = ctx:poly1305_ctx s -> len:size_t -> text:lbuffer uint8 len -> Stack unit (requires fun h -> live h text /\ live h ctx /\ disjoint ctx text /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update (as_seq h0 text) (as_get_acc h0 ctx) (as_get_r h0 ctx))

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1" inline_for_extraction noextract let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s) noextract val as_get_acc: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val as_get_r: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val state_inv_t: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> Type0 // If the ctx is not modified, all the components and invariants are preserved val reveal_ctx_inv': #s:field_spec -> ctx:poly1305_ctx s -> ctx':poly1305_ctx s -> h0:mem -> h1:mem -> Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx') /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx' /\ as_get_acc h0 ctx == as_get_acc h1 ctx' /\ state_inv_t h1 ctx') let reveal_ctx_inv #s ctx h0 h1: Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx) /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h0 ctx == as_get_acc h1 ctx /\ state_inv_t h1 ctx) = reveal_ctx_inv' #s ctx ctx h0 h1 val ctx_inv_zeros: #s:field_spec -> ctx:poly1305_ctx s -> h:mem -> Lemma (requires as_seq h ctx == Lib.Sequence.create (v (nlimb s +! precomplen s)) (limb_zero s)) (ensures state_inv_t #s h ctx) inline_for_extraction noextract let poly1305_init_st (s:field_spec) = ctx:poly1305_ctx s -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key)) [@ Meta.Attribute.specialize ] inline_for_extraction noextract val poly1305_init: #s:field_spec -> poly1305_init_st s inline_for_extraction noextract let poly1305_update1_st (s:field_spec) = ctx:poly1305_ctx s -> b:lbuffer uint8 16ul -> Stack unit (requires fun h -> live h ctx /\ live h b /\ disjoint b ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update1 (as_get_r h0 ctx) 16 (as_seq h0 b) (as_get_acc h0 ctx)) inline_for_extraction noextract val poly1305_update1: (#s:field_spec) -> poly1305_update1_st s

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_update_st (s: field_spec) =

ctx: poly1305_ctx s -> len: size_t -> text: lbuffer uint8 len -> Stack unit (requires fun h -> live h text /\ live h ctx /\ disjoint ctx text /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update (as_seq h0 text) (as_get_acc h0 ctx) (as_get_r h0 ctx))

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_init_st

val poly1305_init_st : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_init_st (s:field_spec) = ctx:poly1305_ctx s -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key))

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1" inline_for_extraction noextract let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s) noextract val as_get_acc: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val as_get_r: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val state_inv_t: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> Type0 // If the ctx is not modified, all the components and invariants are preserved val reveal_ctx_inv': #s:field_spec -> ctx:poly1305_ctx s -> ctx':poly1305_ctx s -> h0:mem -> h1:mem -> Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx') /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx' /\ as_get_acc h0 ctx == as_get_acc h1 ctx' /\ state_inv_t h1 ctx') let reveal_ctx_inv #s ctx h0 h1: Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx) /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h0 ctx == as_get_acc h1 ctx /\ state_inv_t h1 ctx) = reveal_ctx_inv' #s ctx ctx h0 h1 val ctx_inv_zeros: #s:field_spec -> ctx:poly1305_ctx s -> h:mem -> Lemma (requires as_seq h ctx == Lib.Sequence.create (v (nlimb s +! precomplen s)) (limb_zero s)) (ensures state_inv_t #s h ctx)

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_init_st (s: field_spec) =

ctx: poly1305_ctx s -> key: lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.no_lookahead_on

val no_lookahead_on (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

val no_lookahead_on (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x'

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' ))

f: LowParse.Spec.Base.bare_parser t -> x: LowParse.Bytes.bytes -> x': LowParse.Bytes.bytes -> Prims.GTot Type0

Prims.GTot

let no_lookahead_on (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0 =

no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x'

LowParse.Spec.Base.fsti

LowParse.Spec.Base.no_lookahead

val no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0

val no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0

let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x'

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = ()

f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 =

forall (x: bytes) (x': bytes). {:pattern (no_lookahead_on_precond f x x')\/(no_lookahead_on_postcond f x x')} no_lookahead_on f x x'

LowParse.Spec.Base.fsti

LowParse.Spec.Base.injective_postcond

val injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0

val injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0

let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = ()

p: LowParse.Spec.Base.bare_parser t -> b1: LowParse.Bytes.bytes -> b2: LowParse.Bytes.bytes -> Prims.GTot Type0

Prims.GTot

let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 =

Some? (parse p b1) /\ Some? (parse p b2) /\ (let Some (v1, len1) = parse p b1 in let Some (v2, len2) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.injective_precond

val injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0

val injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0

let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *)

p: LowParse.Spec.Base.bare_parser t -> b1: LowParse.Bytes.bytes -> b2: LowParse.Bytes.bytes -> Prims.GTot Type0

Prims.GTot

let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 =

Some? (parse p b1) /\ Some? (parse p b2) /\ (let Some (v1, len1) = parse p b1 in let Some (v2, len2) = parse p b2 in v1 == v2)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.is_total_constant_size_parser

val is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

val is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = ()

sz: Prims.nat -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 =

forall (s: bytes). {:pattern (parse f s)} (Seq.length s < sz) == (None? (parse f s))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.no_lookahead_on_postcond

val no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

val no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' ))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off )

f: LowParse.Spec.Base.bare_parser t -> x: LowParse.Bytes.bytes -> x': LowParse.Bytes.bytes -> Prims.GTot Type0

Prims.GTot

let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0 =

Some? (parse f x) ==> (let Some v = parse f x in let y, _ = v in Some? (parse f x') /\ (let Some v' = parse f x' in let y', _ = v' in y == y'))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parser_always_fails

val parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0

val parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0

let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal)

f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 =

forall input. {:pattern (parse f input)} parse f input == None

LowParse.Spec.Base.fsti

LowParse.Spec.Base.no_lookahead_on_precond

val no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

val no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0

let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1))

f: LowParse.Spec.Base.bare_parser t -> x: LowParse.Bytes.bytes -> x': LowParse.Bytes.bytes -> Prims.GTot Type0

Prims.GTot

let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x': bytes) : GTot Type0 =

Some? (parse f x) /\ (let Some v = parse f x in let _, off = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.injective_ext

val injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (injective p2 <==> injective p1))

val injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (injective p2 <==> injective p1))

let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2

p1: LowParse.Spec.Base.bare_parser t -> p2: LowParse.Spec.Base.bare_parser t -> FStar.Pervasives.Lemma (requires forall (b: LowParse.Bytes.bytes). LowParse.Spec.Base.parse p2 b == LowParse.Spec.Base.parse p1 b) (ensures LowParse.Spec.Base.injective p2 <==> LowParse.Spec.Base.injective p1)

FStar.Pervasives.Lemma

let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (injective p2 <==> injective p1)) =

Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parser_kind

val parser_kind : Type0

let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high })

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; }

Type0

Prims.Tot

let parser_kind =

(x: parser_kind'{Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high})

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parser_kind_prop'

val parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0

val parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0

let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f

k: LowParse.Spec.Base.parser_kind -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 =

injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.consumes_all

val consumes_all (#t: Type) (p: bare_parser t) : GTot Type0

val consumes_all (#t: Type) (p: bare_parser t) : GTot Type0

let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *)

p: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 =

forall (b: bytes). {:pattern (parse p b)} Some? (parse p b) ==> (let Some (_, len) = parse p b in Seq.length b == len)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parses_at_most

val parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

val parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *)

sz: Prims.nat -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 =

forall (s: bytes). {:pattern (parse f s)} Some? (parse f s) ==> (let _, consumed = Some?.v (parse f s) in sz >= (consumed <: nat))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.no_lookahead_ext

val no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (no_lookahead p2 <==> no_lookahead p1))

val no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (no_lookahead p2 <==> no_lookahead p1))

let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x'

p1: LowParse.Spec.Base.bare_parser t -> p2: LowParse.Spec.Base.bare_parser t -> FStar.Pervasives.Lemma (requires forall (b: LowParse.Bytes.bytes). LowParse.Spec.Base.parse p2 b == LowParse.Spec.Base.parse p1 b) (ensures LowParse.Spec.Base.no_lookahead p2 <==> LowParse.Spec.Base.no_lookahead p1)

FStar.Pervasives.Lemma

let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires (forall (b: bytes). parse p2 b == parse p1 b)) (ensures (no_lookahead p2 <==> no_lookahead p1)) =

Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parses_at_least

val parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

val parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *)

sz: Prims.nat -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 =

forall (s: bytes). {:pattern (parse f s)} Some? (parse f s) ==> (let _, consumed = Some?.v (parse f s) in sz <= (consumed <: nat))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.get_parser_kind

val get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind

val get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind

let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } )

p: LowParse.Spec.Base.parser k t -> LowParse.Spec.Base.parser_kind

Prims.Tot

let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind =

k

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parser_subkind_prop

val parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0

val parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0

let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll

k: LowParse.Spec.Base.parser_subkind -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 =

match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.is_constant_size_parser

val is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

val is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0

let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) )

sz: Prims.nat -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 =

forall (s: bytes). {:pattern (parse f s)} Some? (parse f s) ==> (let _, consumed = Some?.v (parse f s) in sz == (consumed <: nat))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce_to_bare_parser

val coerce_to_bare_parser (t: Type) (k2: parser_kind) (p: parser k2 t) : Tot (bare_parser t)

val coerce_to_bare_parser (t: Type) (k2: parser_kind) (p: parser k2 t) : Tot (bare_parser t)

let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f))

t: Type -> k2: LowParse.Spec.Base.parser_kind -> p: LowParse.Spec.Base.parser k2 t -> LowParse.Spec.Base.bare_parser t

Prims.Tot

let coerce_to_bare_parser (t: Type) (k2: parser_kind) (p: parser k2 t) : Tot (bare_parser t) =

p

LowParse.Spec.Base.fsti

LowParse.Spec.Base.strong_parser_kind

val strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True))

val strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True))

let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; }

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high })

lo: Prims.nat -> hi: Prims.nat -> md: LowParse.Spec.Base.parser_kind_metadata_t -> Prims.Pure LowParse.Spec.Base.parser_kind

Prims.Pure

let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) =

{ parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md }

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parser_kind_metadata_prop

val parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0

val parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0

let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None

k: LowParse.Spec.Base.parser_kind -> f: LowParse.Spec.Base.bare_parser t -> Prims.GTot Type0

Prims.GTot

let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 =

match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce_to_tot_bare_parser

val coerce_to_tot_bare_parser (t: Type) (k2: parser_kind) (p: tot_parser k2 t) : Tot (tot_bare_parser t)

val coerce_to_tot_bare_parser (t: Type) (k2: parser_kind) (p: tot_parser k2 t) : Tot (tot_bare_parser t)

let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t

t: Type -> k2: LowParse.Spec.Base.parser_kind -> p: LowParse.Spec.Base.tot_parser k2 t -> LowParse.Spec.Base.tot_bare_parser t

Prims.Tot

let coerce_to_tot_bare_parser (t: Type) (k2: parser_kind) (p: tot_parser k2 t) : Tot (tot_bare_parser t) =

p

LowParse.Spec.Base.fsti

LowParse.Spec.Base.total_constant_size_parser_kind

val total_constant_size_parser_kind (sz: nat) : Tot parser_kind

val total_constant_size_parser_kind (sz: nat) : Tot parser_kind

let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; }

sz: Prims.nat -> LowParse.Spec.Base.parser_kind

Prims.Tot

let total_constant_size_parser_kind (sz: nat) : Tot parser_kind =

strong_parser_kind sz sz (Some ParserKindMetadataTotal)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.weaken

val weaken (k1 #k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True))

val weaken (k1 #k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True))

let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p

k1: LowParse.Spec.Base.parser_kind -> p2: LowParse.Spec.Base.parser k2 t -> Prims.Pure (LowParse.Spec.Base.parser k1 t)

Prims.Pure

let weaken (k1 #k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) =

let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t

LowParse.Spec.Base.fsti

LowParse.Spec.Base.is_weaker_than

val is_weaker_than (k1 k2: parser_kind) : GTot Type0

val is_weaker_than (k1 k2: parser_kind) : GTot Type0

let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high ))))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong)

k1: LowParse.Spec.Base.parser_kind -> k2: LowParse.Spec.Base.parser_kind -> Prims.GTot Type0

Prims.GTot

let is_weaker_than (k1 k2: parser_kind) : GTot Type0 =

(Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ((Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> (Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high))))

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_update1_st

val poly1305_update1_st : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_update1_st (s:field_spec) = ctx:poly1305_ctx s -> b:lbuffer uint8 16ul -> Stack unit (requires fun h -> live h ctx /\ live h b /\ disjoint b ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update1 (as_get_r h0 ctx) 16 (as_seq h0 b) (as_get_acc h0 ctx))

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1" inline_for_extraction noextract let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s) noextract val as_get_acc: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val as_get_r: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val state_inv_t: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> Type0 // If the ctx is not modified, all the components and invariants are preserved val reveal_ctx_inv': #s:field_spec -> ctx:poly1305_ctx s -> ctx':poly1305_ctx s -> h0:mem -> h1:mem -> Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx') /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx' /\ as_get_acc h0 ctx == as_get_acc h1 ctx' /\ state_inv_t h1 ctx') let reveal_ctx_inv #s ctx h0 h1: Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx) /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h0 ctx == as_get_acc h1 ctx /\ state_inv_t h1 ctx) = reveal_ctx_inv' #s ctx ctx h0 h1 val ctx_inv_zeros: #s:field_spec -> ctx:poly1305_ctx s -> h:mem -> Lemma (requires as_seq h ctx == Lib.Sequence.create (v (nlimb s +! precomplen s)) (limb_zero s)) (ensures state_inv_t #s h ctx) inline_for_extraction noextract let poly1305_init_st (s:field_spec) = ctx:poly1305_ctx s -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key)) [@ Meta.Attribute.specialize ] inline_for_extraction noextract val poly1305_init: #s:field_spec -> poly1305_init_st s

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_update1_st (s: field_spec) =

ctx: poly1305_ctx s -> b: lbuffer uint8 16ul -> Stack unit (requires fun h -> live h ctx /\ live h b /\ disjoint b ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update1 (as_get_r h0 ctx) 16 (as_seq h0 b) (as_get_acc h0 ctx))

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_finish_st

val poly1305_finish_st : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_finish_st (s:field_spec) = tag:lbuffer uint8 16ul -> key:lbuffer uint8 32ul -> ctx:poly1305_ctx s -> Stack unit (requires fun h -> live h tag /\ live h key /\ live h ctx /\ disjoint tag key /\ disjoint tag ctx /\ disjoint key ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc tag |+| loc ctx) h0 h1 /\ as_seq h1 tag == S.poly1305_finish (as_seq h0 key) (as_get_acc h0 ctx))

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1" inline_for_extraction noextract let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s) noextract val as_get_acc: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val as_get_r: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val state_inv_t: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> Type0 // If the ctx is not modified, all the components and invariants are preserved val reveal_ctx_inv': #s:field_spec -> ctx:poly1305_ctx s -> ctx':poly1305_ctx s -> h0:mem -> h1:mem -> Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx') /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx' /\ as_get_acc h0 ctx == as_get_acc h1 ctx' /\ state_inv_t h1 ctx') let reveal_ctx_inv #s ctx h0 h1: Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx) /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h0 ctx == as_get_acc h1 ctx /\ state_inv_t h1 ctx) = reveal_ctx_inv' #s ctx ctx h0 h1 val ctx_inv_zeros: #s:field_spec -> ctx:poly1305_ctx s -> h:mem -> Lemma (requires as_seq h ctx == Lib.Sequence.create (v (nlimb s +! precomplen s)) (limb_zero s)) (ensures state_inv_t #s h ctx) inline_for_extraction noextract let poly1305_init_st (s:field_spec) = ctx:poly1305_ctx s -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key)) [@ Meta.Attribute.specialize ] inline_for_extraction noextract val poly1305_init: #s:field_spec -> poly1305_init_st s inline_for_extraction noextract let poly1305_update1_st (s:field_spec) = ctx:poly1305_ctx s -> b:lbuffer uint8 16ul -> Stack unit (requires fun h -> live h ctx /\ live h b /\ disjoint b ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update1 (as_get_r h0 ctx) 16 (as_seq h0 b) (as_get_acc h0 ctx)) inline_for_extraction noextract val poly1305_update1: (#s:field_spec) -> poly1305_update1_st s inline_for_extraction noextract let poly1305_update_st (s:field_spec) = ctx:poly1305_ctx s -> len:size_t -> text:lbuffer uint8 len -> Stack unit (requires fun h -> live h text /\ live h ctx /\ disjoint ctx text /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update (as_seq h0 text) (as_get_acc h0 ctx) (as_get_r h0 ctx)) inline_for_extraction noextract [@ Meta.Attribute.specialize ] val poly1305_update: #s:field_spec -> poly1305_update_st s

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_finish_st (s: field_spec) =

tag: lbuffer uint8 16ul -> key: lbuffer uint8 32ul -> ctx: poly1305_ctx s -> Stack unit (requires fun h -> live h tag /\ live h key /\ live h ctx /\ disjoint tag key /\ disjoint tag ctx /\ disjoint key ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc tag |+| loc ctx) h0 h1 /\ as_seq h1 tag == S.poly1305_finish (as_seq h0 key) (as_get_acc h0 ctx))

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_ctx

val poly1305_ctx : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s)

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1"

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_ctx (s: field_spec) =

lbuffer (limb s) (nlimb s +! precomplen s)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.bool_and

val bool_and (b1 b2: bool) : Tot (y: bool{y == (b1 && b2)})

val bool_and (b1 b2: bool) : Tot (y: bool{y == (b1 && b2)})

let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"]

b1: Prims.bool -> b2: Prims.bool -> y: Prims.bool{y == (b1 && b2)}

Prims.Tot

let bool_and (b1 b2: bool) : Tot (y: bool{y == (b1 && b2)}) =

if b1 then b2 else false

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serialize

val serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes

val serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes

let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2

s: LowParse.Spec.Base.serializer p -> x: t -> Prims.GTot LowParse.Bytes.bytes

Prims.GTot

let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes =

s x

LowParse.Spec.Base.fsti

LowParse.Spec.Base.tot_strengthen

val tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True))

val tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True))

let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t

k: LowParse.Spec.Base.parser_kind -> f: LowParse.Spec.Base.tot_bare_parser t -> Prims.Pure (LowParse.Spec.Base.tot_parser k t)

Prims.Pure

let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) =

f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.some_v

val some_v (#t: Type) (x: option t {Some? x}) : Tot (y: t{y == Some?.v x})

val some_v (#t: Type) (x: option t {Some? x}) : Tot (y: t{y == Some?.v x})

let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"]

x: FStar.Pervasives.Native.option t {Some? x} -> y: t{y == Some?.v x}

Prims.Tot

let some_v (#t: Type) (x: option t {Some? x}) : Tot (y: t{y == Some?.v x}) =

match x with | Some y -> y

LowParse.Spec.Base.fsti

LowParse.Spec.Base.bool_or

val bool_or (b1 b2: bool) : Tot (y: bool{y == (b1 || b2)})

val bool_or (b1 b2: bool) : Tot (y: bool{y == (b1 || b2)})

let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"]

b1: Prims.bool -> b2: Prims.bool -> y: Prims.bool{y == (b1 || b2)}

Prims.Tot

let bool_or (b1 b2: bool) : Tot (y: bool{y == (b1 || b2)}) =

if b1 then true else b2

LowParse.Spec.Base.fsti

LowParse.Spec.Base.is_strong

val is_strong (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (r: bool{r ==> k.parser_kind_subkind == Some (ParserStrong)})

val is_strong (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (r: bool{r ==> k.parser_kind_subkind == Some (ParserStrong)})

let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = ()

p: LowParse.Spec.Base.parser k t -> r: Prims.bool { r ==> Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong }

Prims.Tot

let is_strong (#k: parser_kind) (#t: Type) (p: parser k t) : Tot (r: bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) =

k.parser_kind_subkind = Some (ParserStrong)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.tot_weaken

val tot_weaken (k1 #k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True))

val tot_weaken (k1 #k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True))

let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p

k1: LowParse.Spec.Base.parser_kind -> p2: LowParse.Spec.Base.tot_parser k2 t -> Prims.Pure (LowParse.Spec.Base.tot_parser k1 t)

Prims.Pure

let tot_weaken (k1 #k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) =

let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t

Hacl.Impl.Poly1305.fsti

Hacl.Impl.Poly1305.poly1305_mac_st

val poly1305_mac_st : s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

let poly1305_mac_st (s:field_spec) = output:lbuffer uint8 16ul -> input:buffer uint8 -> input_len:size_t { length input = v input_len } -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h input /\ live h output /\ live h key /\ disjoint output input /\ disjoint output key) (ensures fun h0 _ h1 -> modifies (loc output) h0 h1 /\ as_seq h1 output == S.poly1305_mac (as_seq h0 (input <: lbuffer uint8 input_len)) (as_seq h0 key))

module Hacl.Impl.Poly1305 open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer open Hacl.Impl.Poly1305.Fields module S = Spec.Poly1305 #reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 1" inline_for_extraction noextract let poly1305_ctx (s:field_spec) = lbuffer (limb s) (nlimb s +! precomplen s) noextract val as_get_acc: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val as_get_r: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> GTot S.felem noextract val state_inv_t: #s:field_spec -> h:mem -> ctx:poly1305_ctx s -> Type0 // If the ctx is not modified, all the components and invariants are preserved val reveal_ctx_inv': #s:field_spec -> ctx:poly1305_ctx s -> ctx':poly1305_ctx s -> h0:mem -> h1:mem -> Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx') /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx' /\ as_get_acc h0 ctx == as_get_acc h1 ctx' /\ state_inv_t h1 ctx') let reveal_ctx_inv #s ctx h0 h1: Lemma (requires Seq.equal (as_seq h0 ctx) (as_seq h1 ctx) /\ state_inv_t h0 ctx) (ensures as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h0 ctx == as_get_acc h1 ctx /\ state_inv_t h1 ctx) = reveal_ctx_inv' #s ctx ctx h0 h1 val ctx_inv_zeros: #s:field_spec -> ctx:poly1305_ctx s -> h:mem -> Lemma (requires as_seq h ctx == Lib.Sequence.create (v (nlimb s +! precomplen s)) (limb_zero s)) (ensures state_inv_t #s h ctx) inline_for_extraction noextract let poly1305_init_st (s:field_spec) = ctx:poly1305_ctx s -> key:lbuffer uint8 32ul -> Stack unit (requires fun h -> live h ctx /\ live h key /\ disjoint ctx key) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ (as_get_acc h1 ctx, as_get_r h1 ctx) == S.poly1305_init (as_seq h0 key)) [@ Meta.Attribute.specialize ] inline_for_extraction noextract val poly1305_init: #s:field_spec -> poly1305_init_st s inline_for_extraction noextract let poly1305_update1_st (s:field_spec) = ctx:poly1305_ctx s -> b:lbuffer uint8 16ul -> Stack unit (requires fun h -> live h ctx /\ live h b /\ disjoint b ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update1 (as_get_r h0 ctx) 16 (as_seq h0 b) (as_get_acc h0 ctx)) inline_for_extraction noextract val poly1305_update1: (#s:field_spec) -> poly1305_update1_st s inline_for_extraction noextract let poly1305_update_st (s:field_spec) = ctx:poly1305_ctx s -> len:size_t -> text:lbuffer uint8 len -> Stack unit (requires fun h -> live h text /\ live h ctx /\ disjoint ctx text /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc ctx) h0 h1 /\ state_inv_t #s h1 ctx /\ as_get_r h0 ctx == as_get_r h1 ctx /\ as_get_acc h1 ctx == S.poly1305_update (as_seq h0 text) (as_get_acc h0 ctx) (as_get_r h0 ctx)) inline_for_extraction noextract [@ Meta.Attribute.specialize ] val poly1305_update: #s:field_spec -> poly1305_update_st s inline_for_extraction noextract let poly1305_finish_st (s:field_spec) = tag:lbuffer uint8 16ul -> key:lbuffer uint8 32ul -> ctx:poly1305_ctx s -> Stack unit (requires fun h -> live h tag /\ live h key /\ live h ctx /\ disjoint tag key /\ disjoint tag ctx /\ disjoint key ctx /\ state_inv_t #s h ctx) (ensures fun h0 _ h1 -> modifies (loc tag |+| loc ctx) h0 h1 /\ as_seq h1 tag == S.poly1305_finish (as_seq h0 key) (as_get_acc h0 ctx)) [@ Meta.Attribute.specialize ] noextract inline_for_extraction val poly1305_finish: #s:field_spec -> poly1305_finish_st s

s: Hacl.Impl.Poly1305.Fields.field_spec -> Type0

Prims.Tot

let poly1305_mac_st (s: field_spec) =

output: lbuffer uint8 16ul -> input: buffer uint8 -> input_len: size_t{length input = v input_len} -> key: lbuffer uint8 32ul -> Stack unit (requires fun h -> live h input /\ live h output /\ live h key /\ disjoint output input /\ disjoint output key) (ensures fun h0 _ h1 -> modifies (loc output) h0 h1 /\ as_seq h1 output == S.poly1305_mac (as_seq h0 (input <: lbuffer uint8 input_len)) (as_seq h0 key))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.default_parser_kind

val default_parser_kind:(x: parser_kind { forall (t: Type) (p: bare_parser t). {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p })

val default_parser_kind:(x: parser_kind { forall (t: Type) (p: bare_parser t). {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p })

let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options

x: LowParse.Spec.Base.parser_kind { forall (t: Type) (p: LowParse.Spec.Base.bare_parser t). {:pattern LowParse.Spec.Base.parser_kind_prop x p} LowParse.Spec.Base.injective p ==> LowParse.Spec.Base.parser_kind_prop x p }

Prims.Tot

let default_parser_kind:(x: parser_kind { forall (t: Type) (p: bare_parser t). {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) =

let aux (t: Type) (k: parser_kind) (p: bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None } in x

LowParse.Spec.Base.fsti

LowParse.Spec.Base.strengthen

val strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True))

val strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True))

let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f

k: LowParse.Spec.Base.parser_kind -> f: LowParse.Spec.Base.bare_parser t -> Prims.Pure (LowParse.Spec.Base.parser k t)

Prims.Pure

let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) =

f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serializer_complete

val serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0

val serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0

let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len )

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = ()

p: LowParse.Spec.Base.parser k t -> f: LowParse.Spec.Base.bare_serializer t -> Prims.GTot Type0

Prims.GTot

let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 =

forall (s: bytes). {:pattern (parse p s)} Some? (parse p s) ==> (let Some (x, len) = parse p s in f x == Seq.slice s 0 len)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.is_some

val is_some (#t: Type) (x: option t) : Tot (y: bool{y == Some? x})

val is_some (#t: Type) (x: option t) : Tot (y: bool{y == Some? x})

let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"]

x: FStar.Pervasives.Native.option t -> y: Prims.bool{y == Some? x}

Prims.Tot

let is_some (#t: Type) (x: option t) : Tot (y: bool{y == Some? x}) =

match x with | Some _ -> true | _ -> false

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce_parser

val coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True))

val coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True))

let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2)

t2: Type -> p: LowParse.Spec.Base.parser k t1 -> Prims.Pure (LowParse.Spec.Base.parser k t2)

Prims.Pure

let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) =

p

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce'

val coerce' (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True))

val coerce' (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True))

let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2)

t2: Type -> x: t1 -> Prims.Pure t2

Prims.Pure

let coerce' (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) =

(x <: t2)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.glb_list_of

val glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k'. (Cons? l /\ (forall kl. L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k)))

val glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k'. (Cons? l /\ (forall kl. L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k)))

let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k'

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot

f: (_: t -> LowParse.Spec.Base.parser_kind) -> l: Prims.list t -> Prims.Pure LowParse.Spec.Base.parser_kind

Prims.Pure

let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k'. (Cons? l /\ (forall kl. L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k))) =

match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k'

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serializer_correct

val serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0

val serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0

let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes

p: LowParse.Spec.Base.parser k t -> f: LowParse.Spec.Base.bare_serializer t -> Prims.GTot Type0

Prims.GTot

let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 =

forall (x: t). {:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.glb_list

val glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl)))

val glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl)))

let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options

l: Prims.list LowParse.Spec.Base.parser_kind -> Prims.Pure LowParse.Spec.Base.parser_kind

Prims.Pure

let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl. {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl))) =

glb_list_of id l

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce

val coerce (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True))

val coerce (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True))

let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold

t2: Type -> x: t1 -> Prims.Pure t2

Prims.Pure

let coerce (t2 #t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) =

(x <: t2)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.mk_serializer

val mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: (x: t -> Lemma (parse p (f x) == Some (x, Seq.length (f x))))) : Tot (serializer p)

val mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: (x: t -> Lemma (parse p (f x) == Some (x, Seq.length (f x))))) : Tot (serializer p)

let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } )

p: LowParse.Spec.Base.parser k t -> f: LowParse.Spec.Base.bare_serializer t -> prf: (x: t -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse p (f x) == FStar.Pervasives.Native.Some (x, FStar.Seq.Base.length (f x)))) -> LowParse.Spec.Base.serializer p

Prims.Tot

let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: (x: t -> Lemma (parse p (f x) == Some (x, Seq.length (f x))))) : Tot (serializer p) =

Classical.forall_intro prf; f

LowParse.Spec.Base.fsti

LowParse.Spec.Base.coerce_serializer

val coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit{t2 == t1}) : Tot (serializer (coerce_parser t2 p))

val coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit{t2 == t1}) : Tot (serializer (coerce_parser t2 p))

let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f

t2: Type -> s: LowParse.Spec.Base.serializer p -> u467: u468: Prims.unit{t2 == t1} -> LowParse.Spec.Base.serializer (LowParse.Spec.Base.coerce_parser t2 p)

Prims.Tot

let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit{t2 == t1}) : Tot (serializer (coerce_parser t2 p)) =

s

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serialize_ext

val serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input))) (ensures (fun _ -> True))

val serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input))) (ensures (fun _ -> True))

let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s

p1: LowParse.Spec.Base.parser k1 t1 -> s1: LowParse.Spec.Base.serializer p1 -> p2: LowParse.Spec.Base.parser k2 t2 -> Prims.Pure (LowParse.Spec.Base.serializer p2)

Prims.Pure

let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes). parse p1 input == parse p2 input))) (ensures (fun _ -> True)) =

serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.glb

val glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2))

val glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2))

let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None }

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2

k1: LowParse.Spec.Base.parser_kind -> k2: LowParse.Spec.Base.parser_kind -> Prims.Pure LowParse.Spec.Base.parser_kind

Prims.Pure

let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2)) =

match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with | Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None) } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = (if (is_some k1.parser_kind_high) `bool_and` (is_some k2.parser_kind_high) then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None }

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serializer_unique

val serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x)

val serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x)

let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x

p: LowParse.Spec.Base.parser k t -> s1: LowParse.Spec.Base.serializer p -> s2: LowParse.Spec.Base.serializer p -> x: t -> FStar.Pervasives.Lemma (ensures s1 x == s2 x)

FStar.Pervasives.Lemma

let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) =

let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parsed_data_is_serialize

val parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures (let Some (y, consumed) = parse p x in ((serialize s y) `Seq.append` (Seq.slice x consumed (Seq.length x))) `Seq.equal` x))

val parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures (let Some (y, consumed) = parse p x in ((serialize s y) `Seq.append` (Seq.slice x consumed (Seq.length x))) `Seq.equal` x))

let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = ()

s: LowParse.Spec.Base.serializer p -> x: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (requires Some? (LowParse.Spec.Base.parse p x)) (ensures (let _ = LowParse.Spec.Base.parse p x in (let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ y consumed) = _ in FStar.Seq.Base.equal (FStar.Seq.Base.append (LowParse.Spec.Base.serialize s y) (FStar.Seq.Base.slice x consumed (FStar.Seq.Base.length x))) x) <: Type0))

FStar.Pervasives.Lemma

let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures (let Some (y, consumed) = parse p x in ((serialize s y) `Seq.append` (Seq.slice x consumed (Seq.length x))) `Seq.equal` x)) =

let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serialize_ext'

val serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True))

val serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True))

let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2)

p1: LowParse.Spec.Base.parser k1 t1 -> s1: LowParse.Spec.Base.serializer p1 -> p2: LowParse.Spec.Base.parser k2 t2 -> Prims.Pure (LowParse.Spec.Base.serializer p2)

Prims.Pure

let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) =

serialize_ext p1 s1 p2

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serialize_strong_prefix

val serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires (k.parser_kind_subkind == Some ParserStrong /\ (serialize s x1) `Seq.append` q1 == (serialize s x2) `Seq.append` q2)) (ensures (x1 == x2 /\ q1 == q2))

val serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires (k.parser_kind_subkind == Some ParserStrong /\ (serialize s x1) `Seq.append` q1 == (serialize s x2) `Seq.append` q2)) (ensures (x1 == x2 /\ q1 == q2))

let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)]

s: LowParse.Spec.Base.serializer p -> x1: t -> x2: t -> q1: LowParse.Bytes.bytes -> q2: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (requires Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\ FStar.Seq.Base.append (LowParse.Spec.Base.serialize s x1) q1 == FStar.Seq.Base.append (LowParse.Spec.Base.serialize s x2) q2) (ensures x1 == x2 /\ q1 == q2)

FStar.Pervasives.Lemma

let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires (k.parser_kind_subkind == Some ParserStrong /\ (serialize s x1) `Seq.append` q1 == (serialize s x2) `Seq.append` q2)) (ensures (x1 == x2 /\ q1 == q2)) =

parse_strong_prefix p (serialize s x1) ((serialize s x1) `Seq.append` q1); parse_strong_prefix p (serialize s x2) ((serialize s x2) `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq

val seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True))

val seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True))

let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s)))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> Prims.Pure (s_: FStar.Seq.Base.seq t {FStar.Seq.Base.length s_ == FStar.Seq.Base.length s})

Prims.Pure

let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) =

Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s)))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serializer_parser_unique

val serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires (is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s) ) (ensures (p1 x == p2 x))

val serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires (is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s) ) (ensures (p1 x == p2 x))

let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else ()

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x ))

p1: LowParse.Spec.Base.parser k1 t -> p2: LowParse.Spec.Base.parser k2 t -> s: LowParse.Spec.Base.bare_serializer t -> x: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (requires LowParse.Spec.Base.is_strong p1 /\ LowParse.Spec.Base.is_strong p2 /\ LowParse.Spec.Base.serializer_correct p1 s /\ LowParse.Spec.Base.serializer_correct p2 s) (ensures p1 x == p2 x)

FStar.Pervasives.Lemma

let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires (is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s) ) (ensures (p1 x == p2 x)) =

if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x

LowParse.Spec.Base.fsti

LowParse.Spec.Base.serializer_injective

val serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2))

val serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2))

let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2

p: LowParse.Spec.Base.parser k t -> s: LowParse.Spec.Base.serializer p -> x1: t -> x2: t -> FStar.Pervasives.Lemma (requires s x1 == s x2) (ensures x1 == x2)

FStar.Pervasives.Lemma

let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) =

assert (parse p (s x1) == parse p (s x2))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice'

val seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i)))

val seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i)))

let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s')

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> j1: Prims.nat -> j2: Prims.nat -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + FStar.Seq.Base.length s') (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') j1 j2 == FStar.Seq.Base.slice s' (j1 - i) (j2 - i))

FStar.Pervasives.Lemma

let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) =

seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_seq_upd

val seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x)))

val seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x)))

let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) = assert (Seq.upd s i x `Seq.equal` seq_upd_seq s i (Seq.create 1 x))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3) let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1)

s: FStar.Seq.Base.seq t -> i: Prims.nat -> x: t -> FStar.Pervasives.Lemma (requires i < FStar.Seq.Base.length s) (ensures FStar.Seq.Base.upd s i x == LowParse.Spec.Base.seq_upd_seq s i (FStar.Seq.Base.create 1 x))

FStar.Pervasives.Lemma

let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) =

assert ((Seq.upd s i x) `Seq.equal` (seq_upd_seq s i (Seq.create 1 x)))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_right

val seq_upd_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s'))

val seq_upd_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s'))

let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))

s: FStar.Seq.Base.seq t -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures LowParse.Spec.Base.seq_upd_seq s (FStar.Seq.Base.length s - FStar.Seq.Base.length s') s' == FStar.Seq.Base.append (FStar.Seq.Base.slice s 0 (FStar.Seq.Base.length s - FStar.Seq.Base.length s')) s')

FStar.Pervasives.Lemma

let seq_upd_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) =

assert ((seq_upd_seq s (Seq.length s - Seq.length s') s') `Seq.equal` (Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s'))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice

val seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s'))

val seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s'))

let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s')

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = ()

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') i (i + FStar.Seq.Base.length s') == s')

FStar.Pervasives.Lemma

let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) =

assert ((Seq.slice (seq_upd_seq s i s') i (i + Seq.length s')) `Seq.equal` s')

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice_left

val seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i))

val seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i))

let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i)

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') 0 i == FStar.Seq.Base.slice s 0 i)

FStar.Pervasives.Lemma

let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) =

assert ((Seq.slice (seq_upd_seq s i s') 0 i) `Seq.equal` (Seq.slice s 0 i))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.parse_truncate

val parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) (x: t) (n: nat) : Lemma (requires (n < Seq.length (serialize s x))) (ensures (parse p (Seq.slice (serialize s x) 0 n) == None))

val parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) (x: t) (n: nat) : Lemma (requires (n < Seq.length (serialize s x))) (ensures (parse p (Seq.slice (serialize s x) 0 n) == None))

let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2

s: LowParse.Spec.Base.serializer p { Mkparser_kind'?.parser_kind_subkind k == FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } -> x: t -> n: Prims.nat -> FStar.Pervasives.Lemma (requires n < FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x)) (ensures LowParse.Spec.Base.parse p (FStar.Seq.Base.slice (LowParse.Spec.Base.serialize s x) 0 n) == FStar.Pervasives.Native.None)

FStar.Pervasives.Lemma

let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p {k.parser_kind_subkind == Some ParserStrong}) (x: t) (n: nat) : Lemma (requires (n < Seq.length (serialize s x))) (ensures (parse p (Seq.slice (serialize s x) 0 n) == None)) =

let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice_left'

val seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2))

val seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2))

let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i)

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> j1: Prims.nat -> j2: Prims.nat -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s /\ j1 <= j2 /\ j2 <= i) (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') j1 j2 == FStar.Seq.Base.slice s j1 j2)

FStar.Pervasives.Lemma

let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) =

seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_empty

val seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s))

val seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s))

let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s'))

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i <= FStar.Seq.Base.length s /\ FStar.Seq.Base.length s' == 0) (ensures LowParse.Spec.Base.seq_upd_seq s i s' == s)

FStar.Pervasives.Lemma

let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) =

assert ((seq_upd_seq s i s') `Seq.equal` s)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_bw_seq

val seq_upd_bw_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True))

val seq_upd_bw_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True))

let seq_upd_bw_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = seq_upd_seq s (Seq.length s - i - Seq.length s') s'

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3) let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1) let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) = assert (Seq.upd s i x `Seq.equal` seq_upd_seq s i (Seq.create 1 x)) let seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sl : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` seq_upd_seq s i' s' == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s' )) = assert (sl `Seq.append` seq_upd_seq s i' s' `Seq.equal` seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s') let seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sr : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( i' <= Seq.length (s `Seq.append` sr) /\ seq_upd_seq s i' s' `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s' )) = assert ((seq_upd_seq s i' s' `Seq.append` sr) `Seq.equal` seq_upd_seq (s `Seq.append` sr) i' s')

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> Prims.Pure (s_: FStar.Seq.Base.seq t {FStar.Seq.Base.length s_ == FStar.Seq.Base.length s})

Prims.Pure

let seq_upd_bw_seq (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Pure (s_: Seq.seq t {Seq.length s_ == Seq.length s}) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) =

seq_upd_seq s (Seq.length s - i - Seq.length s') s'

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice_right

val seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s)))

val seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s)))

let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') (i + FStar.Seq.Base.length s') (FStar.Seq.Base.length s) == FStar.Seq.Base.slice s (i + FStar.Seq.Base.length s') (FStar.Seq.Base.length s))

FStar.Pervasives.Lemma

let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) =

assert ((Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s)) `Seq.equal` (Seq.slice s (i + Seq.length s') (Seq.length s)))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice_idem

val seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s))

val seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s))

let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s)

s: FStar.Seq.Base.seq t -> lo: Prims.nat -> hi: Prims.nat -> FStar.Pervasives.Lemma (requires lo <= hi /\ hi <= FStar.Seq.Base.length s) (ensures LowParse.Spec.Base.seq_upd_seq s lo (FStar.Seq.Base.slice s lo hi) == s)

FStar.Pervasives.Lemma

let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) =

assert ((seq_upd_seq s lo (Seq.slice s lo hi)) `Seq.equal` s)

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_left

val seq_upd_seq_left (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))))

val seq_upd_seq_left (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))))

let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s)

s: FStar.Seq.Base.seq t -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures LowParse.Spec.Base.seq_upd_seq s 0 s' == FStar.Seq.Base.append s' (FStar.Seq.Base.slice s (FStar.Seq.Base.length s') (FStar.Seq.Base.length s)))

FStar.Pervasives.Lemma

let seq_upd_seq_left (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) =

assert ((seq_upd_seq s 0 s') `Seq.equal` (Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_slice_right'

val seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2))

val seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2))

let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s'))

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s))

s: FStar.Seq.Base.seq t -> i: Prims.nat -> s': FStar.Seq.Base.seq t -> j1: Prims.nat -> j2: Prims.nat -> FStar.Pervasives.Lemma (requires i + FStar.Seq.Base.length s' <= j1 /\ j1 <= j2 /\ j2 <= FStar.Seq.Base.length s) (ensures FStar.Seq.Base.slice (LowParse.Spec.Base.seq_upd_seq s i s') j1 j2 == FStar.Seq.Base.slice s j1 j2)

FStar.Pervasives.Lemma

let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s': Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) =

seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s'))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_right_to_left

val seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 ))

val seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 ))

let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')

s1: FStar.Seq.Base.seq t -> i1: Prims.nat -> s2: FStar.Seq.Base.seq t -> i2: Prims.nat -> s3: FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i1 + FStar.Seq.Base.length s2 <= FStar.Seq.Base.length s1 /\ i2 + FStar.Seq.Base.length s3 <= FStar.Seq.Base.length s2) (ensures LowParse.Spec.Base.seq_upd_seq s1 i1 (LowParse.Spec.Base.seq_upd_seq s2 i2 s3) == LowParse.Spec.Base.seq_upd_seq (LowParse.Spec.Base.seq_upd_seq s1 i1 s2) (i1 + i2) s3)

FStar.Pervasives.Lemma

let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) =

assert ((seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3)) `Seq.equal` (seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_append_seq_upd_seq_r

val seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' sr: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (i' <= Seq.length (s `Seq.append` sr) /\ (seq_upd_seq s i' s') `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s'))

val seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' sr: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (i' <= Seq.length (s `Seq.append` sr) /\ (seq_upd_seq s i' s') `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s'))

let seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sr : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( i' <= Seq.length (s `Seq.append` sr) /\ seq_upd_seq s i' s' `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s' )) = assert ((seq_upd_seq s i' s' `Seq.append` sr) `Seq.equal` seq_upd_seq (s `Seq.append` sr) i' s')

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3) let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1) let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) = assert (Seq.upd s i x `Seq.equal` seq_upd_seq s i (Seq.create 1 x)) let seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sl : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` seq_upd_seq s i' s' == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s' )) = assert (sl `Seq.append` seq_upd_seq s i' s' `Seq.equal` seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s')

s: FStar.Seq.Base.seq t -> i': Prims.nat -> s': FStar.Seq.Base.seq t -> sr: FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures i' <= FStar.Seq.Base.length (FStar.Seq.Base.append s sr) /\ FStar.Seq.Base.append (LowParse.Spec.Base.seq_upd_seq s i' s') sr == LowParse.Spec.Base.seq_upd_seq (FStar.Seq.Base.append s sr) i' s')

FStar.Pervasives.Lemma

let seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' sr: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (i' <= Seq.length (s `Seq.append` sr) /\ (seq_upd_seq s i' s') `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s')) =

assert (((seq_upd_seq s i' s') `Seq.append` sr) `Seq.equal` (seq_upd_seq (s `Seq.append` sr) i' s'))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_seq_upd_seq_slice

val seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1 hi i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3))

val seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1 hi i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3))

let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3)

s1: FStar.Seq.Base.seq t -> i1: Prims.nat -> hi: Prims.nat -> i2: Prims.nat -> s3: FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i1 <= hi /\ hi <= FStar.Seq.Base.length s1 /\ i1 + i2 + FStar.Seq.Base.length s3 <= hi) (ensures LowParse.Spec.Base.seq_upd_seq s1 i1 (LowParse.Spec.Base.seq_upd_seq (FStar.Seq.Base.slice s1 i1 hi) i2 s3) == LowParse.Spec.Base.seq_upd_seq s1 (i1 + i2) s3)

FStar.Pervasives.Lemma

let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1 hi i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3)) =

assert ((seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3)) `Seq.equal` (seq_upd_seq s1 (i1 + i2) s3))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_seq_disj_comm

val seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires (i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1))) (ensures (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1))

val seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires (i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1))) (ensures (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1))

let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1)

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3)

s: FStar.Seq.Base.seq t -> i1: Prims.nat -> s1: FStar.Seq.Base.seq t -> i2: Prims.nat -> s2: FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i1 + FStar.Seq.Base.length s1 <= FStar.Seq.Base.length s /\ i2 + FStar.Seq.Base.length s2 <= FStar.Seq.Base.length s /\ (i1 + FStar.Seq.Base.length s1 <= i2 \/ i2 + FStar.Seq.Base.length s2 <= i1)) (ensures LowParse.Spec.Base.seq_upd_seq (LowParse.Spec.Base.seq_upd_seq s i1 s1) i2 s2 == LowParse.Spec.Base.seq_upd_seq (LowParse.Spec.Base.seq_upd_seq s i2 s2) i1 s1)

FStar.Pervasives.Lemma

let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires (i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1))) (ensures (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1)) =

assert ((seq_upd_seq (seq_upd_seq s i1 s1) i2 s2) `Seq.equal` (seq_upd_seq (seq_upd_seq s i2 s2) i1 s1))

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_upd_bw_seq_right

val seq_upd_bw_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_bw_seq s 0 s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s'))

val seq_upd_bw_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_bw_seq s 0 s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s'))

let seq_upd_bw_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_bw_seq s 0 s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = seq_upd_seq_right s s'

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3) let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1) let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) = assert (Seq.upd s i x `Seq.equal` seq_upd_seq s i (Seq.create 1 x)) let seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sl : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` seq_upd_seq s i' s' == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s' )) = assert (sl `Seq.append` seq_upd_seq s i' s' `Seq.equal` seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s') let seq_append_seq_upd_seq_r (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sr : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( i' <= Seq.length (s `Seq.append` sr) /\ seq_upd_seq s i' s' `Seq.append` sr == seq_upd_seq (s `Seq.append` sr) i' s' )) = assert ((seq_upd_seq s i' s' `Seq.append` sr) `Seq.equal` seq_upd_seq (s `Seq.append` sr) i' s') let seq_upd_bw_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = seq_upd_seq s (Seq.length s - i - Seq.length s') s'

s: FStar.Seq.Base.seq t -> s': FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures LowParse.Spec.Base.seq_upd_bw_seq s 0 s' == FStar.Seq.Base.append (FStar.Seq.Base.slice s 0 (FStar.Seq.Base.length s - FStar.Seq.Base.length s')) s')

FStar.Pervasives.Lemma

let seq_upd_bw_seq_right (#t: Type) (s s': Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_bw_seq s 0 s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) =

seq_upd_seq_right s s'

LowParse.Spec.Base.fsti

LowParse.Spec.Base.seq_append_seq_upd_seq_l

val seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' sl: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` (seq_upd_seq s i' s') == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s'))

val seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' sl: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` (seq_upd_seq s i' s') == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s'))

let seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' : Seq.seq t) (sl : Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures ( Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` seq_upd_seq s i' s' == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s' )) = assert (sl `Seq.append` seq_upd_seq s i' s' `Seq.equal` seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s')

module LowParse.Spec.Base include LowParse.Bytes include LowParse.Norm module Seq = FStar.Seq module U8 = FStar.UInt8 module U32 = FStar.UInt32 /// parse a value of type t /// /// - the parser can fail (currently reporting an uninformative [None]) /// - it returns the parsed value as well as the number of bytes read /// (this is intended to be the number of bytes to advance the input pointer) /// /// note that the type now forbids lookahead; the parser cannot depend on /// values beyond the returned offset /// /// these parsers are used as specifications, and thus use unrepresentable types /// such as byte sequences and natural numbers and are always pure [@"substitute"] inline_for_extraction let consumed_length (b: bytes) : Tot Type = (n: nat { n <= Seq.length b } ) inline_for_extraction let bare_parser (t:Type) : Tot Type = (b: bytes) -> GTot (option (t * consumed_length b)) let parse (#t: Type) (p: bare_parser t) (input: bytes) : GTot (option (t * consumed_length input)) = p input (** Injectivity of parsing *) let injective_precond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in v1 == v2 ) let injective_precond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_precond p2 b1 b2 <==> injective_precond p1 b1 b2 )) = () let injective_postcond (#t: Type) (p: bare_parser t) (b1 b2: bytes) : GTot Type0 = Some? (parse p b1) /\ Some? (parse p b2) /\ ( let (Some (v1, len1)) = parse p b1 in let (Some (v2, len2)) = parse p b2 in (len1 <: nat) == (len2 <: nat) /\ Seq.slice b1 0 len1 == Seq.slice b2 0 len2 ) let injective_postcond_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( injective_postcond p2 b1 b2 <==> injective_postcond p1 b1 b2 )) = () let injective (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b1 b2: bytes) . {:pattern (injective_precond p b1 b2) \/ (injective_postcond p b1 b2)} injective_precond p b1 b2 ==> injective_postcond p b1 b2 let injective_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( injective p2 <==> injective p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_precond_ext p1 p2 b1)); Classical.forall_intro_2 (fun b1 -> Classical.move_requires (injective_postcond_ext p1 p2 b1)) let no_lookahead_on_precond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) /\ ( let (Some v) = parse f x in let (_, off) = v in off <= Seq.length x' /\ Seq.slice x' 0 off == Seq.slice x 0 off ) let no_lookahead_on_postcond (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = Some? (parse f x) ==> ( let (Some v) = parse f x in let (y, _) = v in Some? (parse f x') /\ ( let (Some v') = parse f x' in let (y', _) = v' in y == y' )) let no_lookahead_on (#t: Type) (f: bare_parser t) (x x' : bytes) : GTot Type0 = no_lookahead_on_precond f x x' ==> no_lookahead_on_postcond f x x' let no_lookahead_on_ext (#t: Type) (p1 p2: bare_parser t) (b1 b2: bytes) : Lemma (requires ( parse p2 b1 == parse p1 b1 /\ parse p2 b2 == parse p1 b2 )) (ensures ( no_lookahead_on p2 b1 b2 <==> no_lookahead_on p1 b1 b2 )) = () let no_lookahead (#t: Type) (f: bare_parser t) : GTot Type0 = forall (x x' : bytes) . {:pattern (no_lookahead_on_precond f x x') \/ (no_lookahead_on_postcond f x x')} no_lookahead_on f x x' let no_lookahead_ext (#t: Type) (p1 p2: bare_parser t) : Lemma (requires ( forall (b: bytes) . parse p2 b == parse p1 b )) (ensures ( no_lookahead p2 <==> no_lookahead p1 )) = Classical.forall_intro_2 (fun b1 -> Classical.move_requires (no_lookahead_on_ext p1 p2 b1)) (** A parser that always consumes all its input *) let consumes_all (#t: Type) (p: bare_parser t) : GTot Type0 = forall (b: bytes) . {:pattern (parse p b)} Some? (parse p b) ==> ( let (Some (_, len)) = parse p b in Seq.length b == len ) (** Parsing data of bounded size *) let parses_at_least (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz <= (consumed <: nat) ) let parses_at_least_0 (#t: Type) (f: bare_parser t) : Lemma (parses_at_least 0 f) = () let parses_at_least_le (sz sz': nat) (#t: Type) (f: bare_parser t) : Lemma (requires ( parses_at_least sz f /\ sz' <= sz )) (ensures ( parses_at_least sz' f )) = () (** A parser that always consumes at least one byte. A list can be serialized only if the parser for elements always consumes at least one byte. Anyway, since we require such a parser to have the prefix property, this is always true except for the parser for empty data. *) let parses_at_most (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz >= (consumed <: nat) ) let is_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s)} Some? (parse f s) ==> ( let (_, consumed) = Some?.v (parse f s) in sz == (consumed <: nat) ) let is_constant_size_parser_equiv (sz: nat) (#t: Type) (f: bare_parser t) : Lemma (is_constant_size_parser sz f <==> (parses_at_least sz f /\ parses_at_most sz f)) = () let is_total_constant_size_parser (sz: nat) (#t: Type) (f: bare_parser t) : GTot Type0 = forall (s: bytes) . {:pattern (parse f s) } (Seq.length s < sz) == (None? (parse f s)) type parser_subkind = | ParserStrong | ParserConsumesAll let parser_subkind_prop (k: parser_subkind) (#t: Type) (f: bare_parser t) : GTot Type0 = match k with | ParserStrong -> no_lookahead f | ParserConsumesAll -> consumes_all f type parser_kind_metadata_some = | ParserKindMetadataTotal | ParserKindMetadataFail type parser_kind_metadata_t = option parser_kind_metadata_some inline_for_extraction type parser_kind' = { parser_kind_low: nat; parser_kind_high: option nat; parser_kind_subkind: option parser_subkind; parser_kind_metadata: parser_kind_metadata_t; } let parser_kind = (x: parser_kind' { Some? x.parser_kind_high ==> x.parser_kind_low <= Some?.v x.parser_kind_high }) inline_for_extraction let strong_parser_kind (lo hi: nat) (md: parser_kind_metadata_t) : Pure parser_kind (requires (lo <= hi)) (ensures (fun _ -> True)) = { parser_kind_low = lo; parser_kind_high = Some hi; parser_kind_subkind = Some ParserStrong; parser_kind_metadata = md; } inline_for_extraction let total_constant_size_parser_kind (sz: nat) : Tot parser_kind = strong_parser_kind sz sz (Some ParserKindMetadataTotal) let parser_always_fails (#t: Type) (f: bare_parser t) : GTot Type0 = forall input . {:pattern (parse f input)} parse f input == None let parser_kind_metadata_prop (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = match k.parser_kind_metadata with | None -> True | Some ParserKindMetadataTotal -> k.parser_kind_high == Some k.parser_kind_low ==> is_total_constant_size_parser k.parser_kind_low f | Some ParserKindMetadataFail -> parser_always_fails f let parser_kind_prop' (#t: Type) (k: parser_kind) (f: bare_parser t) : GTot Type0 = injective f /\ (Some? k.parser_kind_subkind ==> parser_subkind_prop (Some?.v k.parser_kind_subkind) f) /\ parses_at_least k.parser_kind_low f /\ (Some? k.parser_kind_high ==> (parses_at_most (Some?.v k.parser_kind_high) f)) /\ parser_kind_metadata_prop k f val parser_kind_prop (#a:Type) (k:parser_kind) (f:bare_parser a) : GTot Type0 val parser_kind_prop_equiv (#t: Type) (k: parser_kind) (f: bare_parser t) : Lemma (parser_kind_prop k f <==> parser_kind_prop' k f) val parser_kind_prop_ext (#t: Type) (k: parser_kind) (f1 f2: bare_parser t) : Lemma (requires (forall (input: bytes) . parse f1 input == parse f2 input)) (ensures (parser_kind_prop k f1 <==> parser_kind_prop k f2)) [@unifier_hint_injective] inline_for_extraction let parser (k: parser_kind) (t: Type) : Tot Type = (f: bare_parser t { parser_kind_prop k f } ) inline_for_extraction let tot_bare_parser (t:Type) : Tot Type = (b: bytes) -> Tot (option (t * consumed_length b)) [@unifier_hint_injective] let tot_parser (k: parser_kind) (t: Type) : Tot Type = (f: tot_bare_parser t { parser_kind_prop k f } ) inline_for_extraction let get_parser_kind (#k: parser_kind) (#t: Type) (p: parser k t) : Tot parser_kind = k inline_for_extraction let get_parser_type (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = t let parser_kind_prop_intro (k: parser_kind) (#t: Type) (f: parser k t) : Lemma (parser_kind_prop k f) = () let is_strong (#k:parser_kind) (#t:Type) (p:parser k t) : Tot (r:bool{r ==> k.parser_kind_subkind == Some (ParserStrong)}) = k.parser_kind_subkind = Some (ParserStrong) let is_weaker_than (k1 k2: parser_kind) : GTot Type0 = (Some? k1.parser_kind_metadata ==> k1.parser_kind_metadata == k2.parser_kind_metadata) /\ ((k1.parser_kind_metadata <> Some ParserKindMetadataFail /\ k2.parser_kind_metadata <> Some ParserKindMetadataFail) ==> ( (Some? k1.parser_kind_subkind ==> k1.parser_kind_subkind == k2.parser_kind_subkind) /\ k1.parser_kind_low <= k2.parser_kind_low /\ (Some? k1.parser_kind_high ==> ( Some? k2.parser_kind_high /\ Some?.v k2.parser_kind_high <= Some?.v k1.parser_kind_high )))) val is_weaker_than_correct (k1: parser_kind) (k2: parser_kind) (#t: Type) (f: bare_parser t) : Lemma (requires (parser_kind_prop k2 f /\ k1 `is_weaker_than` k2)) (ensures (parser_kind_prop k1 f)) (* AR: see bug#1349 *) unfold let coerce_to_bare_parser (t:Type) (k2:parser_kind) (p:parser k2 t) :Tot (bare_parser t) = p let weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: parser k2 t) : Pure (parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: parser k1 t unfold let coerce_to_tot_bare_parser (t:Type) (k2:parser_kind) (p:tot_parser k2 t) :Tot (tot_bare_parser t) = p let tot_weaken (k1: parser_kind) (#k2: parser_kind) (#t: Type) (p2: tot_parser k2 t) : Pure (tot_parser k1 t) (requires (k1 `is_weaker_than` k2)) (ensures (fun _ -> True)) = let p = coerce_to_tot_bare_parser t k2 p2 in is_weaker_than_correct k1 k2 p; p <: tot_parser k1 t // inline_for_extraction let tot_strengthen (k: parser_kind) (#t: Type) (f: tot_bare_parser t) : Pure (tot_parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f // inline_for_extraction let strengthen (k: parser_kind) (#t: Type) (f: bare_parser t) : Pure (parser k t) (requires (parser_kind_prop k f)) (ensures (fun _ -> True)) = f #push-options "--z3rlimit 16" [@"opaque_to_smt"] inline_for_extraction let is_some (#t: Type) (x: option t) : Tot (y: bool { y == Some? x }) = match x with | Some _ -> true | _ -> false [@"opaque_to_smt"] inline_for_extraction let some_v (#t: Type) (x: option t { Some? x }) : Tot (y: t { y == Some?.v x }) = match x with | Some y -> y [@"opaque_to_smt"] inline_for_extraction let bool_and (b1 b2: bool) : Tot (y: bool { y == (b1 && b2) }) = if b1 then b2 else false [@"opaque_to_smt"] inline_for_extraction let bool_or (b1 b2: bool) : Tot (y: bool { y == (b1 || b2) }) = if b1 then true else b2 inline_for_extraction let glb (k1 k2: parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> k `is_weaker_than` k1 /\ k `is_weaker_than` k2 // (forall k' . (k' `is_weaker_than` k1 /\ k' `is_weaker_than` k2) ==> k' `is_weaker_than` k) )) = match k1.parser_kind_metadata, k2.parser_kind_metadata with | _, Some ParserKindMetadataFail -> { parser_kind_low = k1.parser_kind_low; parser_kind_high = k1.parser_kind_high; parser_kind_subkind = k1.parser_kind_subkind; parser_kind_metadata = (match k1.parser_kind_metadata with Some ParserKindMetadataFail -> Some ParserKindMetadataFail | _ -> None); } | Some ParserKindMetadataFail, _ -> { parser_kind_low = k2.parser_kind_low; parser_kind_high = k2.parser_kind_high; parser_kind_subkind = k2.parser_kind_subkind; parser_kind_metadata = None; } | _ -> { parser_kind_low = (if k1.parser_kind_low < k2.parser_kind_low then k1.parser_kind_low else k2.parser_kind_low); parser_kind_high = ( if is_some k1.parser_kind_high `bool_and` is_some k2.parser_kind_high then if some_v k2.parser_kind_high < some_v k1.parser_kind_high then k1.parser_kind_high else k2.parser_kind_high else None ); parser_kind_metadata = if k1.parser_kind_metadata = k2.parser_kind_metadata then k1.parser_kind_metadata else None; parser_kind_subkind = if k1.parser_kind_subkind = k2.parser_kind_subkind then k1.parser_kind_subkind else None } #pop-options #push-options "--warn_error -271" let default_parser_kind : (x: parser_kind { forall (t: Type) (p: bare_parser t) . {:pattern (parser_kind_prop x p)} injective p ==> parser_kind_prop x p }) = let aux (t:Type) (k:parser_kind) (p:bare_parser t) : Lemma (parser_kind_prop k p <==> parser_kind_prop' k p) [SMTPat ()] = parser_kind_prop_equiv k p in let x = { parser_kind_low = 0; parser_kind_high = None; parser_kind_metadata = None; parser_kind_subkind = None; } in x #pop-options // #set-options "--max_fuel 8 --max_ifuel 8" module L = FStar.List.Tot let rec glb_list_of (#t: eqtype) (f: (t -> Tot parser_kind)) (l: list t) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . L.mem kl l ==> k `is_weaker_than` (f kl)) /\ (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` (f kl))) ==> k' `is_weaker_than` k) )) = match l with | [] -> default_parser_kind | [k] -> f k | k1 :: q -> let k' = glb_list_of f q in glb (f k1) k' #reset-options let glb_list (l: list parser_kind) : Pure parser_kind (requires True) (ensures (fun k -> (forall kl . {:pattern (L.mem kl l)} L.mem kl l ==> k `is_weaker_than` kl) // (forall k' . (Cons? l /\ (forall kl . L.mem kl l ==> k' `is_weaker_than` kl)) ==> k' `is_weaker_than` k) )) = glb_list_of id l (* Coercions *) unfold inline_for_extraction let coerce (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) let coerce' (t2: Type) (#t1: Type) (x: t1) : Pure t2 (requires (t1 == t2)) (ensures (fun _ -> True)) = (x <: t2) unfold let coerce_parser (t2: Type) (#k: parser_kind) (#t1: Type) (p: parser k t1) : Pure (parser k t2) (requires (t2 == t1)) (ensures (fun _ -> True)) = p val parse_injective (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( injective_precond p input1 input2 )) (ensures ( injective_postcond p input1 input2 )) val parse_strong_prefix (#k: parser_kind) (#t: Type) (p: parser k t) (input1: bytes) (input2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ Seq.slice input1 0 consumed `Seq.equal` Seq.slice input2 0 consumed | _ -> False ))) (ensures ( match parse p input1 with | Some (x, consumed) -> consumed <= Seq.length input2 /\ parse p input2 == Some (x, consumed) | _ -> False )) (* Pure serializers *) inline_for_extraction let bare_serializer (t: Type) : Tot Type = t -> GTot bytes let serializer_correct (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (x: t) .{:pattern (parse p (f x))} parse p (f x) == Some (x, Seq.length (f x)) let serializer_correct_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (f: bare_serializer t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Lemma (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (serializer_correct p1 f <==> serializer_correct p2 f)) = () let serializer_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : GTot Type0 = forall (s: bytes) . {:pattern (parse p s)} Some? (parse p s) ==> ( let (Some (x, len)) = parse p s in f x == Seq.slice s 0 len ) val serializer_correct_implies_complete (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) : Lemma (requires (serializer_correct p f)) (ensures (serializer_complete p f)) [@unifier_hint_injective] inline_for_extraction let serializer (#k: parser_kind) (#t: Type) (p: parser k t) : Tot Type = (f: bare_serializer t { serializer_correct p f } ) let mk_serializer (#k: parser_kind) (#t: Type) (p: parser k t) (f: bare_serializer t) (prf: ( (x: t) -> Lemma (parse p (f x) == Some (x, Seq.length (f x))) )) : Tot (serializer p) = Classical.forall_intro prf; f unfold let coerce_serializer (t2: Type) (#k: parser_kind) (#t1: Type) (#p: parser k t1) (s: serializer p) (u: unit { t2 == t1 } ) : Tot (serializer (coerce_parser t2 p)) = s let serialize_ext (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ (forall (input: bytes) . parse p1 input == parse p2 input))) (ensures (fun _ -> True)) = serializer_correct_ext p1 s1 p2; (s1 <: bare_serializer t2) let serialize_ext' (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (s1: serializer p1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Pure (serializer p2) (requires (t1 == t2 /\ k1 == k2 /\ p1 == p2)) (ensures (fun _ -> True)) = serialize_ext p1 s1 p2 let serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : GTot bytes = s x let parse_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (parse p (serialize s x) == Some (x, Seq.length (serialize s x))) = () let parsed_data_is_serialize (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: bytes) : Lemma (requires (Some? (parse p x))) (ensures ( let Some (y, consumed) = parse p x in (serialize s y `Seq.append` Seq.slice x consumed (Seq.length x)) `Seq.equal` x )) = let Some (y, consumed) = parse p x in parse_injective p (serialize s y) x let serializer_unique (#k: parser_kind) (#t: Type) (p: parser k t) (s1 s2: serializer p) (x: t) : Lemma (s1 x == s2 x) = (* need these because of patterns *) let _ = parse p (s1 x) in let _ = parse p (s2 x) in serializer_correct_implies_complete p s2 let serializer_injective (#k: parser_kind) (#t: Type) (p: parser k t) (s: serializer p) (x1 x2: t) : Lemma (requires (s x1 == s x2)) (ensures (x1 == x2)) = (* patterns, again *) assert (parse p (s x1) == parse p (s x2)) val serializer_parser_unique' (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s /\ Some? (parse p1 x) )) (ensures ( parse p1 x == parse p2 x )) let serializer_parser_unique (#k1: parser_kind) (#t: Type) (p1: parser k1 t) (#k2: parser_kind) (p2: parser k2 t) (s: bare_serializer t) (x: bytes) : Lemma (requires ( is_strong p1 /\ is_strong p2 /\ serializer_correct p1 s /\ serializer_correct p2 s )) (ensures ( p1 x == p2 x )) = if Some? (p1 x) then serializer_parser_unique' p1 p2 s x else if Some? (p2 x) then serializer_parser_unique' p2 p1 s x else () val serialize_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (let x = Seq.length (serialize s x) in k.parser_kind_low <= x /\ ( match k.parser_kind_high with | None -> True | Some y -> x <= y )) [SMTPat (Seq.length (serialize s x))] val serialize_not_fail (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) : Lemma (k.parser_kind_metadata <> Some ParserKindMetadataFail) [SMTPat (serialize s x)] let serialize_strong_prefix (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x1 x2: t) (q1 q2: bytes) : Lemma (requires ( k.parser_kind_subkind == Some ParserStrong /\ serialize s x1 `Seq.append` q1 == serialize s x2 `Seq.append` q2 )) (ensures (x1 == x2 /\ q1 == q2)) = parse_strong_prefix p (serialize s x1) (serialize s x1 `Seq.append` q1); parse_strong_prefix p (serialize s x2) (serialize s x2 `Seq.append` q2); Seq.lemma_append_inj (serialize s x1) q1 (serialize s x2) q2 let parse_truncate (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p { k.parser_kind_subkind == Some ParserStrong }) (x: t) (n: nat) : Lemma (requires ( n < Seq.length (serialize s x) )) (ensures ( parse p (Seq.slice (serialize s x) 0 n) == None )) = let sq0 = serialize s x in let sq1 = Seq.slice sq0 0 n in match parse p sq1 with | None -> () | Some (x', consumed) -> parse_strong_prefix p sq1 sq0 let seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Pure (s_ : Seq.seq t { Seq.length s_ == Seq.length s } ) (requires (i + Seq.length s' <= Seq.length s)) (ensures (fun _ -> True)) = Seq.append (Seq.slice s 0 i) (Seq.append s' (Seq.slice s (i + Seq.length s') (Seq.length s))) let index_seq_upd_seq (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j < Seq.length s)) (ensures ( Seq.index (seq_upd_seq s i s') j == (if i <= j && j < i + Seq.length s' then Seq.index s' (j - i) else Seq.index s j))) = () let seq_upd_seq_slice (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') == s')) = assert (Seq.slice (seq_upd_seq s i s') i (i + Seq.length s') `Seq.equal` s') let seq_upd_seq_slice' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ i <= j1 /\ j1 <= j2 /\ j2 <= i + Seq.length s')) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s' (j1 - i) (j2 - i))) = seq_upd_seq_slice s i s'; Seq.slice_slice (seq_upd_seq s i s') i (i + Seq.length s') (j1 - i) (j2 - i) let seq_upd_seq_slice_left (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') 0 i == Seq.slice s 0 i)) = assert (Seq.slice (seq_upd_seq s i s') 0 i `Seq.equal` Seq.slice s 0 i) let seq_upd_seq_slice_left' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= Seq.length s /\ j1 <= j2 /\ j2 <= i)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_left s i s'; Seq.slice_slice (seq_upd_seq s i s') 0 i j1 j2 let seq_upd_seq_slice_right (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i + Seq.length s' <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) == Seq.slice s (i + Seq.length s') (Seq.length s))) = assert (Seq.slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) `Seq.equal` Seq.slice s (i + Seq.length s') (Seq.length s)) let seq_upd_seq_slice_right' (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) (j1 j2: nat) : Lemma (requires (i + Seq.length s' <= j1 /\ j1 <= j2 /\ j2 <= Seq.length s)) (ensures (Seq.slice (seq_upd_seq s i s') j1 j2 == Seq.slice s j1 j2)) = seq_upd_seq_slice_right s i s'; Seq.slice_slice (seq_upd_seq s i s') (i + Seq.length s') (Seq.length s) (j1 - (i + Seq.length s')) (j2 - (i + Seq.length s')) let seq_upd_seq_empty (#t: Type) (s: Seq.seq t) (i: nat) (s' : Seq.seq t) : Lemma (requires (i <= Seq.length s /\ Seq.length s' == 0)) (ensures (seq_upd_seq s i s' == s)) = assert (seq_upd_seq s i s' `Seq.equal` s) let seq_upd_seq_slice_idem (#t: Type) (s: Seq.seq t) (lo hi: nat) : Lemma (requires (lo <= hi /\ hi <= Seq.length s)) (ensures (seq_upd_seq s lo (Seq.slice s lo hi) == s)) = assert (seq_upd_seq s lo (Seq.slice s lo hi) `Seq.equal` s) let seq_upd_seq_left (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s 0 s' == Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s)))) = assert (seq_upd_seq s 0 s' `Seq.equal` Seq.append s' (Seq.slice s (Seq.length s') (Seq.length s))) let seq_upd_seq_right (#t: Type) (s: Seq.seq t) (s' : Seq.seq t) : Lemma (requires (Seq.length s' <= Seq.length s)) (ensures (seq_upd_seq s (Seq.length s - Seq.length s') s' == Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s')) = assert (seq_upd_seq s (Seq.length s - Seq.length s') s' `Seq.equal` Seq.append (Seq.slice s 0 (Seq.length s - Seq.length s')) s') let seq_upd_seq_right_to_left (#t: Type) (s1: Seq.seq t) (i1: nat) (s2: Seq.seq t) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 + Seq.length s2 <= Seq.length s1 /\ i2 + Seq.length s3 <= Seq.length s2)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) == seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq s2 i2 s3) `Seq.equal` seq_upd_seq (seq_upd_seq s1 i1 s2) (i1 + i2) s3) let seq_upd_seq_seq_upd_seq_slice (#t: Type) (s1: Seq.seq t) (i1: nat) (hi: nat) (i2: nat) (s3: Seq.seq t) : Lemma (requires (i1 <= hi /\ hi <= Seq.length s1 /\ i1 + i2 + Seq.length s3 <= hi)) (ensures ( seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) == seq_upd_seq s1 (i1 + i2) s3 )) = assert (seq_upd_seq s1 i1 (seq_upd_seq (Seq.slice s1 i1 hi) i2 s3) `Seq.equal` seq_upd_seq s1 (i1 + i2) s3) let seq_upd_seq_disj_comm (#t: Type) (s: Seq.seq t) (i1: nat) (s1: Seq.seq t) (i2: nat) (s2: Seq.seq t) : Lemma (requires ( i1 + Seq.length s1 <= Seq.length s /\ i2 + Seq.length s2 <= Seq.length s /\ (i1 + Seq.length s1 <= i2 \/ i2 + Seq.length s2 <= i1) )) (ensures ( seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 == seq_upd_seq (seq_upd_seq s i2 s2) i1 s1 )) = assert (seq_upd_seq (seq_upd_seq s i1 s1) i2 s2 `Seq.equal` seq_upd_seq (seq_upd_seq s i2 s2) i1 s1) let seq_upd_seq_seq_upd (#t: Type) (s: Seq.seq t) (i: nat) (x: t) : Lemma (requires (i < Seq.length s)) (ensures (Seq.upd s i x == seq_upd_seq s i (Seq.create 1 x))) = assert (Seq.upd s i x `Seq.equal` seq_upd_seq s i (Seq.create 1 x))

s: FStar.Seq.Base.seq t -> i': Prims.nat -> s': FStar.Seq.Base.seq t -> sl: FStar.Seq.Base.seq t -> FStar.Pervasives.Lemma (requires i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length s) (ensures FStar.Seq.Base.length sl + i' <= FStar.Seq.Base.length (FStar.Seq.Base.append sl s) /\ FStar.Seq.Base.append sl (LowParse.Spec.Base.seq_upd_seq s i' s') == LowParse.Spec.Base.seq_upd_seq (FStar.Seq.Base.append sl s) (FStar.Seq.Base.length sl + i') s')

FStar.Pervasives.Lemma

let seq_append_seq_upd_seq_l (#t: Type) (s: Seq.seq t) (i': nat) (s' sl: Seq.seq t) : Lemma (requires (i' + Seq.length s' <= Seq.length s)) (ensures (Seq.length sl + i' <= Seq.length (sl `Seq.append` s) /\ sl `Seq.append` (seq_upd_seq s i' s') == seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s')) =

assert ((sl `Seq.append` (seq_upd_seq s i' s')) `Seq.equal` (seq_upd_seq (sl `Seq.append` s) (Seq.length sl + i') s'))

Pulse.Checker.AssertWithBinders.fsti

Pulse.Checker.AssertWithBinders.head_show_proof_state

val head_show_proof_state : st: Pulse.Syntax.Base.st_term -> Prims.bool

let head_show_proof_state (st:st_term) = match st.term with | Tm_ProofHintWithBinders { hint_type = SHOW_PROOF_STATE _ } -> true | _ -> false

(* Copyright 2023 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Pulse.Checker.AssertWithBinders module T = FStar.Tactics.V2 open Pulse.Syntax open Pulse.Typing open Pulse.Checker.Base let head_wild (st:st_term) = match st.term with | Tm_ProofHintWithBinders { hint_type = WILD } -> true | _ -> false

st: Pulse.Syntax.Base.st_term -> Prims.bool

Prims.Tot

let head_show_proof_state (st: st_term) =

match st.term with | Tm_ProofHintWithBinders { hint_type = SHOW_PROOF_STATE _ } -> true | _ -> false

Pulse.Checker.AssertWithBinders.fsti

Pulse.Checker.AssertWithBinders.handle_head_immediately

val handle_head_immediately : st: Pulse.Syntax.Base.st_term -> Prims.bool

let handle_head_immediately st = head_wild st || head_show_proof_state st

(* Copyright 2023 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Pulse.Checker.AssertWithBinders module T = FStar.Tactics.V2 open Pulse.Syntax open Pulse.Typing open Pulse.Checker.Base let head_wild (st:st_term) = match st.term with | Tm_ProofHintWithBinders { hint_type = WILD } -> true | _ -> false let head_show_proof_state (st:st_term) = match st.term with | Tm_ProofHintWithBinders { hint_type = SHOW_PROOF_STATE _ } -> true | _ -> false

st: Pulse.Syntax.Base.st_term -> Prims.bool

Prims.Tot

let handle_head_immediately st =

head_wild st || head_show_proof_state st