effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot
(gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } )) | val gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot
(gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot
(gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k)) = | false | null | false | fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k)
(synth_dsum_case_recip t k)
();
(consumed)
| _ -> (0)
in
(res
<:
(res:
_
{ gaccessor_post' (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
input
res })) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Bytes.bytes",
"Prims.nat",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.parse_dsum_type_of_tag'",
"LowParse.Low.Sum.clens_dsum_payload",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Sum.parse_dsum_eq3",
"LowParse.Low.Base.Spec.gaccessor'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot
(gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k)) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_payload' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_key t
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Sum.parse_dsum t p f g)
(LowParse.Spec.Sum.parse_dsum_type_of_tag' t f g k)
(LowParse.Low.Sum.clens_dsum_payload t k) | {
"end_col": 131,
"end_line": 1839,
"start_col": 2,
"start_line": 1828
} |
Prims.Tot | val serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: (x: sum_key t -> Tot (serializer (dsnd (pc x)))))
(sc32: (x: sum_key t -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos | val serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: (x: sum_key t -> Tot (serializer (dsnd (pc x)))))
(sc32: (x: sum_key t -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: (x: sum_key t -> Tot (serializer (dsnd (pc x)))))
(sc32: (x: sum_key t -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc)) = | false | null | false | fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.serializer32",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.sum_key_type",
"LowParse.Spec.Sum.sum_enum",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Spec.Enum.serialize_enum_key",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Low.Sum.serialize32_sum_cases_t",
"LowParse.Spec.Sum.sum_type",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Low.Combinators.serialize32_nondep_then_aux",
"LowParse.Spec.Sum.weaken_parse_cases_kind",
"LowParse.Spec.Sum.sum_cases",
"LowParse.Spec.Sum.parse_sum_cases",
"LowParse.Spec.Sum.serialize_sum_cases",
"LowParse.Low.Sum.serialize32_sum_cases",
"LowParse.Spec.Sum.sum_tag_of_data",
"Prims.unit",
"LowParse.Spec.Sum.serialize_sum_eq",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.parse_sum",
"LowParse.Spec.Sum.serialize_sum"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: (x: sum_key t -> Tot (serializer (dsnd (pc x)))))
(sc32: (x: sum_key t -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc)) | [] | LowParse.Low.Sum.serialize32_sum | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind kt ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s32:
LowParse.Low.Base.serializer32 (LowParse.Spec.Enum.serialize_enum_key p
s
(LowParse.Spec.Sum.sum_enum t)) ->
sc:
(x: LowParse.Spec.Sum.sum_key t
-> LowParse.Spec.Base.serializer (FStar.Pervasives.dsnd (pc x))) ->
sc32: (x: LowParse.Spec.Sum.sum_key t -> LowParse.Low.Base.serializer32 (sc x)) ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.sum_enum t)
(LowParse.Low.Sum.serialize32_sum_cases_t t sc)
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Sum.serialize_sum t s sc) | {
"end_col": 87,
"end_line": 752,
"start_col": 2,
"start_line": 749
} |
Prims.Tot | val jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos | val jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Low.Base.jumper",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Sum.jump_dsum_cases_t",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Sum.jump_dsum_cases'_destr",
"Prims.unit",
"LowParse.Spec.Sum.parse_dsum_cases_eq'",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.weaken_parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.parse_dsum_cases",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x)) | [] | LowParse.Low.Sum.jump_dsum_cases | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key s
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag s x))) ->
f':
(x: LowParse.Spec.Sum.dsum_known_key s
-> LowParse.Low.Base.jumper (FStar.Pervasives.dsnd (f x))) ->
g': LowParse.Low.Base.jumper g ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum s)
(fun k -> LowParse.Low.Sum.jump_dsum_cases_t s f g (LowParse.Spec.Enum.Known k)) ->
x: LowParse.Spec.Sum.dsum_key s
-> LowParse.Low.Base.jumper (LowParse.Spec.Sum.parse_dsum_cases s f g x) | {
"end_col": 52,
"end_line": 1478,
"start_col": 2,
"start_line": 1470
} |
Prims.Tot | val jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos | val jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) = | false | null | false | fun #rrel #rel input pos ->
match x with
| Known k ->
destr _
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Low.Base.jumper",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Sum.jump_dsum_cases_t",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Sum.jump_dsum_cases_eq",
"LowParse.Low.Sum.jump_dsum_cases_if",
"LowParse.Spec.Enum.if_combinator",
"Prims.unit",
"LowParse.Low.Sum.jump_dsum_cases'",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) | [] | LowParse.Low.Sum.jump_dsum_cases'_destr | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key s
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag s x))) ->
f':
(x: LowParse.Spec.Sum.dsum_known_key s
-> LowParse.Low.Base.jumper (FStar.Pervasives.dsnd (f x))) ->
g': LowParse.Low.Base.jumper g ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum s)
(fun k -> LowParse.Low.Sum.jump_dsum_cases_t s f g (LowParse.Spec.Enum.Known k)) ->
x: LowParse.Spec.Sum.dsum_key s
-> LowParse.Low.Sum.jump_dsum_cases_t s f g x | {
"end_col": 65,
"end_line": 1457,
"start_col": 2,
"start_line": 1445
} |
Prims.Tot | val jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x) | val jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) = | false | null | false | synth_dsum_case_injective s x;
match x with
| Known x' ->
jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' ->
jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Low.Base.jumper",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Combinators.jump_synth",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Low.Sum.jump_dsum_cases_t",
"Prims.unit",
"LowParse.Spec.Sum.synth_dsum_case_injective"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(f': (x: dsum_known_key s -> Tot (jumper (dsnd (f x)))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g': jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x) | [] | LowParse.Low.Sum.jump_dsum_cases' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key s
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag s x))) ->
f':
(x: LowParse.Spec.Sum.dsum_known_key s
-> LowParse.Low.Base.jumper (FStar.Pervasives.dsnd (f x))) ->
g': LowParse.Low.Base.jumper g ->
x: LowParse.Spec.Sum.dsum_key s
-> LowParse.Low.Sum.jump_dsum_cases_t s f g x | {
"end_col": 105,
"end_line": 1432,
"start_col": 2,
"start_line": 1429
} |
Prims.Tot | val jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x | val jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x)) = | false | null | false | jump_dsum_cases_if' s f g x | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Low.Sum.jump_dsum_cases_if'",
"LowParse.Spec.Enum.if_combinator",
"LowParse.Low.Sum.jump_dsum_cases_t",
"LowParse.Low.Sum.jump_dsum_cases_eq"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x))))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x)) | [] | LowParse.Low.Sum.jump_dsum_cases_if | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key s
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag s x))) ->
g: LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_unknown_tag s) ->
x: LowParse.Spec.Sum.dsum_key s
-> LowParse.Spec.Enum.if_combinator (LowParse.Low.Sum.jump_dsum_cases_t s f g x)
(LowParse.Low.Sum.jump_dsum_cases_eq s f g x) | {
"end_col": 29,
"end_line": 1417,
"start_col": 2,
"start_line": 1417
} |
Prims.Tot | val read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos | val read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) = | false | null | false | fun #rrel #rel input pos ->
[@@ inline_let ]let _ = synth_dsum_case_injective t x in
match x with
| Known x' -> read_synth' (dsnd (f x')) (synth_dsum_case t (Known x')) (f32 x') () input pos
| Unknown x' -> read_synth' g (synth_dsum_case t (Unknown x')) g32 () input pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Low.Base.leaf_reader",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Combinators.read_synth'",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"Prims.unit",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) | [] | LowParse.Low.Sum.read_dsum_cases' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
f32:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.leaf_reader (FStar.Pervasives.dsnd (f x))) ->
g: LowParse.Spec.Base.parser k' (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
g32: LowParse.Low.Base.leaf_reader g ->
x: LowParse.Spec.Sum.dsum_key t
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Sum.parse_dsum_cases' t f g x) | {
"end_col": 9,
"end_line": 1541,
"start_col": 2,
"start_line": 1522
} |
Prims.Tot | val read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos | val read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) = | false | null | false | fun #_ #_ input pos ->
match x with
| Known k ->
destr _
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r -> read_dsum_cases' t f f32 g g32 (Unknown r) input pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Low.Base.leaf_reader",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Sum.read_dsum_cases_t",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Sum.read_dsum_cases_t_eq",
"LowParse.Low.Sum.read_dsum_cases_t_if",
"Prims.unit",
"LowParse.Low.Sum.read_dsum_cases'",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x)) | [] | LowParse.Low.Sum.read_dsum_cases | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
f32:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.leaf_reader (FStar.Pervasives.dsnd (f x))) ->
g: LowParse.Spec.Base.parser k' (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
g32: LowParse.Low.Base.leaf_reader g ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum t)
(LowParse.Low.Sum.read_dsum_cases_t t f g) ->
x: LowParse.Spec.Sum.dsum_key t
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Sum.parse_dsum_cases' t f g x) | {
"end_col": 56,
"end_line": 1600,
"start_col": 2,
"start_line": 1587
} |
Prims.Tot | val serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
() | val serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) = | false | null | false | [@@ inline_let ]let _ = synth_dsum_case_injective t tg in
[@@ inline_let ]let _ = synth_dsum_case_inverse t tg in
serialize32_synth (serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Base.serializer",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.serializer32",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Low.Combinators.serialize32_synth",
"LowParse.Spec.Sum.weaken_parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.parse_dsum_type_of_tag",
"LowParse.Spec.Sum.serialize_dsum_type_of_tag",
"LowParse.Low.Sum.serialize32_dsum_type_of_tag",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"Prims.eq2",
"Prims.unit",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.parse_dsum_cases",
"LowParse.Spec.Sum.serialize_dsum_cases"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) | [] | LowParse.Low.Sum.serialize32_dsum_cases_aux | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
sf:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Spec.Base.serializer (FStar.Pervasives.dsnd (f x))) ->
sf32: (x: LowParse.Spec.Sum.dsum_known_key t -> LowParse.Low.Base.serializer32 (sf x)) ->
sg32: LowParse.Low.Base.serializer32 sg ->
tg: LowParse.Spec.Sum.dsum_key t
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Sum.serialize_dsum_cases t f sf g sg tg) | {
"end_col": 6,
"end_line": 1667,
"start_col": 2,
"start_line": 1658
} |
Prims.Tot | val validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (validator (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag | val validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (validator (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (validator (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
[@@ inline_let ]let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ =
valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg))
h
input
(uint64_to_uint32 pos_after_tag)
in
destr (validate_dsum_cases_eq t f g)
(validate_dsum_cases_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_dsum_cases' t f f32 g32)
tg
input
pos_after_tag | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_maybe_enum_destr_t",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Sum.validate_dsum_cases_t",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"LowParse.Low.Sum.validate_dsum_cases_eq",
"LowParse.Low.Sum.validate_dsum_cases_if",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.unit",
"LowParse.Low.Sum.validate_dsum_cases'",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.parse_dsum_cases'",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq'",
"LowParse.Slice.bytes_of_slice_from",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 40,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (validator (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g)) | [] | LowParse.Low.Sum.validate_dsum | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
v: LowParse.Low.Base.validator p ->
p32: LowParse.Low.Base.leaf_reader p ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
f32:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.validator (FStar.Pervasives.dsnd (f x))) ->
g32: LowParse.Low.Base.validator g ->
destr:
LowParse.Spec.Enum.dep_maybe_enum_destr_t (LowParse.Spec.Sum.dsum_enum t)
(LowParse.Low.Sum.validate_dsum_cases_t t f g)
-> LowParse.Low.Base.validator (LowParse.Spec.Sum.parse_dsum t p f g) | {
"end_col": 165,
"end_line": 1094,
"start_col": 2,
"start_line": 1079
} |
FStar.HyperStack.ST.Stack | val finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid g h input pos_payload /\ writable input.base (U32.v pos) (U32.v pos_payload) h))
)
(ensures
(fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
() | val finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid g h input pos_payload /\ writable input.base (U32.v pos) (U32.v pos_payload) h))
)
(ensures
(fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)))
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid g h input pos_payload /\ writable input.base (U32.v pos) (U32.v pos_payload) h))
)
(ensures
(fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload))) = | true | null | false | let pos1 = w r input pos in
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Sum.valid_dsum_intro_unknown",
"LowParse.Spec.Enum.parse_maybe_enum_key_eq",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_length",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Unknown",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid g h input pos_payload /\ writable input.base (U32.v pos) (U32.v pos_payload) h))
)
(ensures
(fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload))) | [] | LowParse.Low.Sum.finalize_dsum_case_unknown | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
s: LowParse.Spec.Base.serializer p ->
w: LowParse.Low.Base.leaf_writer_strong s ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
r: LowParse.Spec.Enum.unknown_enum_repr (LowParse.Spec.Sum.dsum_enum t) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 4,
"end_line": 1248,
"start_col": 1,
"start_line": 1238
} |
Prims.Tot | val serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos | val serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) = | false | null | false | fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr _
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Base.serializer",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.serializer32",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Sum.serialize32_dsum_cases_t",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_cases",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Sum.serialize32_dsum_cases_t_eq",
"LowParse.Low.Sum.serialize32_dsum_cases_t_if",
"Prims.unit",
"LowParse.Low.Sum.serialize32_dsum_cases_aux",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Enum.unknown_enum_repr",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Sum.weaken_parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases",
"LowParse.Spec.Sum.serialize_dsum_cases"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg)) | [] | LowParse.Low.Sum.serialize32_dsum_cases | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
sf:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Spec.Base.serializer (FStar.Pervasives.dsnd (f x))) ->
sf32: (x: LowParse.Spec.Sum.dsum_known_key t -> LowParse.Low.Base.serializer32 (sf x)) ->
sg32: LowParse.Low.Base.serializer32 sg ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum t)
(LowParse.Low.Sum.serialize32_dsum_cases_t t f sf g sg) ->
tg: LowParse.Spec.Sum.dsum_key t
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Sum.serialize_dsum_cases t f sf g sg tg) | {
"end_col": 72,
"end_line": 1735,
"start_col": 2,
"start_line": 1721
} |
Prims.Tot | val clens_dsum_payload (s: dsum) (k: dsum_key s) : Tot (clens (dsum_type s) (dsum_type_of_tag s k)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
} | val clens_dsum_payload (s: dsum) (k: dsum_key s) : Tot (clens (dsum_type s) (dsum_type_of_tag s k))
let clens_dsum_payload (s: dsum) (k: dsum_key s) : Tot (clens (dsum_type s) (dsum_type_of_tag s k)) = | false | null | false | {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get
=
(fun (x: dsum_type s) ->
synth_dsum_case_recip s k x
<:
Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)))
} | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_type_of_tag",
"Prims.eq2",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_dsum_payload (s: dsum) (k: dsum_key s) : Tot (clens (dsum_type s) (dsum_type_of_tag s k)) | [] | LowParse.Low.Sum.clens_dsum_payload | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Sum.dsum -> k: LowParse.Spec.Sum.dsum_key s
-> LowParse.Low.Base.Spec.clens (LowParse.Spec.Sum.dsum_type s)
(LowParse.Spec.Sum.dsum_type_of_tag s k) | {
"end_col": 167,
"end_line": 1806,
"start_col": 4,
"start_line": 1805
} |
Prims.Tot | val serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos | val serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg)) = | false | null | false | fun x #_ #_ output pos ->
[@@ inline_let ]let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_dsum_cases t f sf sf32 sg32 destr tg) tg x output pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.serializer32",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Enum.serialize_maybe_enum_key",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Low.Sum.serialize32_dsum_cases_t",
"LowParse.Spec.Sum.dsum_type",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Low.Combinators.serialize32_nondep_then_aux",
"LowParse.Spec.Sum.weaken_parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Sum.parse_dsum_cases",
"LowParse.Spec.Sum.serialize_dsum_cases",
"LowParse.Low.Sum.serialize32_dsum_cases",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_tag_of_data",
"Prims.unit",
"LowParse.Spec.Sum.serialize_dsum_eq'",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.serialize_dsum"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(sf: (x: dsum_known_key t -> Tot (serializer (dsnd (f x)))))
(sf32: (x: dsum_known_key t -> Tot (serializer32 (sf x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg)) | [] | LowParse.Low.Sum.serialize32_dsum | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind kt ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s32:
LowParse.Low.Base.serializer32 (LowParse.Spec.Enum.serialize_maybe_enum_key p
s
(LowParse.Spec.Sum.dsum_enum t)) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
sf:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Spec.Base.serializer (FStar.Pervasives.dsnd (f x))) ->
sf32: (x: LowParse.Spec.Sum.dsum_known_key t -> LowParse.Low.Base.serializer32 (sf x)) ->
sg32: LowParse.Low.Base.serializer32 sg ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum t)
(LowParse.Low.Sum.serialize32_dsum_cases_t t f sf g sg)
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Sum.serialize_dsum t s f sf g sg) | {
"end_col": 7,
"end_line": 1763,
"start_col": 2,
"start_line": 1753
} |
FStar.Pervasives.Lemma | val valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_dsum t p f g) h input pos))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos ==
dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
() | val valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_dsum t p f g) h input pos))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos ==
dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)))
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_dsum t p f g) h input pos))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos ==
dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))) = | false | null | true | let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq_",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents",
"LowParse.Spec.Sum.dsum_tag_of_data",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_dsum t p f g) h input pos))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos ==
dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))) | [] | LowParse.Low.Sum.valid_dsum_elim_tag | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires LowParse.Low.Base.Spec.valid (LowParse.Spec.Sum.parse_dsum t p f g) h input pos)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos /\
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos ==
LowParse.Spec.Sum.dsum_tag_of_data t
(LowParse.Low.Base.Spec.contents (LowParse.Spec.Sum.parse_dsum t p f g) h input pos)) | {
"end_col": 4,
"end_line": 1272,
"start_col": 1,
"start_line": 1269
} |
Prims.Tot | val clens_dsum_unknown_payload (s: dsum) : Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
} | val clens_dsum_unknown_payload (s: dsum) : Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
let clens_dsum_unknown_payload (s: dsum) : Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s)) = | false | null | false | {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get
=
(fun (x: dsum_type s) ->
synth_dsum_case_recip s (dsum_tag_of_data s x) x
<:
Ghost (dsum_type_of_unknown_tag s)
(requires (Unknown? (dsum_tag_of_data s x)))
(ensures (fun _ -> True)))
} | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"Prims.b2t",
"LowParse.Spec.Enum.uu___is_Unknown",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_dsum_unknown_payload (s: dsum) : Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s)) | [] | LowParse.Low.Sum.clens_dsum_unknown_payload | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: LowParse.Spec.Sum.dsum
-> LowParse.Low.Base.Spec.clens (LowParse.Spec.Sum.dsum_type s)
(LowParse.Spec.Sum.dsum_type_of_unknown_tag s) | {
"end_col": 200,
"end_line": 1814,
"start_col": 4,
"start_line": 1813
} |
FStar.HyperStack.ST.Stack | val finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h)))
(ensures
(fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
() | val finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h)))
(ensures
(fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)))
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h)))
(ensures
(fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) = | true | null | false | let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@@ inline_let ]let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.enum_repr_of_key'_t",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Sum.valid_dsum_intro_known",
"LowParse.Spec.Enum.parse_maybe_enum_key_eq",
"LowParse.Spec.Enum.parse_enum_key_eq",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Enum.parse_enum_key",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Enum.write_enum_key",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.writable",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_length",
"LowParse.Spec.Enum.serialize_enum_key",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Known",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires
(fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\
(let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h)))
(ensures
(fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` (U32.uint_to_t len_tag) in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g)
h'
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) | [] | LowParse.Low.Sum.finalize_dsum_case_known | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
s: LowParse.Spec.Base.serializer p ->
w: LowParse.Low.Base.leaf_writer_strong s ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
destr: LowParse.Spec.Enum.enum_repr_of_key'_t (LowParse.Spec.Sum.dsum_enum t) ->
k: LowParse.Spec.Sum.dsum_known_key t ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 4,
"end_line": 1208,
"start_col": 1,
"start_line": 1197
} |
FStar.HyperStack.ST.Stack | val accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)))
(ensures
(fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos | val accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)))
(ensures
(fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos))
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)))
(ensures
(fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos)) = | true | null | false | let h = HST.get () in
[@@ inline_let ]let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.parse_dsum_eq3",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.parse_dsum_type_of_tag'",
"LowParse.Low.Sum.clens_dsum_payload",
"LowParse.Low.Sum.gaccessor_clens_dsum_payload",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.get_valid_pos",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.contents",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.eq2",
"LowParse.Low.Base.Spec.slice_access"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)))
(ensures
(fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos)) | [] | LowParse.Low.Sum.accessor_clens_dsum_payload' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
j: LowParse.Low.Base.jumper p ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_key t ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | {
"end_col": 13,
"end_line": 1936,
"start_col": 1,
"start_line": 1925
} |
Prims.Tot | val read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos' | val read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g)) = | false | null | false | fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos';
read_dsum_cases t f f32 g g32 destr k input pos' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Low.Sum.read_dsum_cases_t",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Sum.read_dsum_cases",
"LowParse.Spec.Sum.dsum_cases",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Low.Enum.jump_maybe_enum_key",
"LowParse.Spec.Sum.parse_dsum_eq_",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.parse_dsum",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(f32: (x: dsum_known_key t -> Tot (leaf_reader (dsnd (f x)))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g)) | [] | LowParse.Low.Sum.read_dsum | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p32:
LowParse.Low.Base.leaf_reader (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t)) ->
j: LowParse.Low.Base.jumper p ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
f32:
(x: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.leaf_reader (FStar.Pervasives.dsnd (f x))) ->
g32: LowParse.Low.Base.leaf_reader g ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.dsum_enum t)
(LowParse.Low.Sum.read_dsum_cases_t t f g)
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Sum.parse_dsum t p f g) | {
"end_col": 50,
"end_line": 1626,
"start_col": 2,
"start_line": 1618
} |
FStar.Pervasives.Lemma | val valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_sum t p pc) h input pos))
(ensures
(valid p h input pos /\
(let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos (parse_sum t p pc)
h
input
pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> () | val valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_sum t p pc) h input pos))
(ensures
(valid p h input pos /\
(let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos (parse_sum t p pc)
h
input
pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False)))
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_sum t p pc) h input pos))
(ensures
(valid p h input pos /\
(let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos (parse_sum t p pc)
h
input
pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False))) = | false | null | true | let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@@ inline_let ]let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@@ inline_let ]let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> () | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Sum.sum_key_type",
"LowParse.Spec.Sum.sum_enum",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Enum.maybe_enum_key",
"Prims.unit",
"Prims._assert",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.UInt32.uint_to_t",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"LowParse.Spec.Sum.parse_sum_eq''",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"LowParse.Spec.Sum.sum_tag_of_data",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_False",
"Prims.logical",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid (parse_sum t p pc) h input pos))
(ensures
(valid p h input pos /\
(let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos (parse_sum t p pc)
h
input
pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False))) | [] | LowParse.Low.Sum.valid_sum_elim | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires LowParse.Low.Base.Spec.valid (LowParse.Spec.Sum.parse_sum t p pc) h input pos)
(ensures
LowParse.Low.Base.Spec.valid p h input pos /\
(let pos_payload = LowParse.Low.Base.Spec.get_valid_pos p h input pos in
let k' =
LowParse.Spec.Enum.maybe_enum_key_of_repr (LowParse.Spec.Sum.sum_enum t)
(LowParse.Low.Base.Spec.contents p h input pos)
in
(match k' with
| LowParse.Spec.Enum.Known #_ #_ #_ k ->
k ==
LowParse.Spec.Sum.sum_tag_of_data t
(LowParse.Low.Base.Spec.contents (LowParse.Spec.Sum.parse_sum t p pc) h input pos) /\
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (pc k)) h input pos_payload /\
LowParse.Low.Base.Spec.valid_pos (LowParse.Spec.Sum.parse_sum t p pc)
h
input
pos
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (pc k))
h
input
pos_payload)
| _ -> Prims.l_False)
<:
Prims.logical)) | {
"end_col": 11,
"end_line": 477,
"start_col": 1,
"start_line": 466
} |
Prims.Tot | val validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload:
(k: sum_repr_type t
-> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))))
: Tot (validator (parse_sum t p pc)) | [
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end | val validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload:
(k: sum_repr_type t
-> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))))
: Tot (validator (parse_sum t p pc))
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload:
(k: sum_repr_type t
-> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))))
: Tot (validator (parse_sum t p pc)) = | false | null | false | fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
[@@ inline_let ]let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Low.Sum.validate_sum_aux_payload_t",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"LowParse.Spec.Sum.sum_key_type",
"LowParse.Spec.Sum.sum_enum",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"Prims.unit",
"LowParse.Spec.Enum.enum_key",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Spec.Enum.maybe_enum_key",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"LowParse.Spec.Sum.parse_sum_eq''",
"LowParse.Slice.bytes_of_slice_from"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload:
(k: sum_repr_type t
-> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))))
: Tot (validator (parse_sum t p pc)) | [] | LowParse.Low.Sum.validate_sum_aux | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
v: LowParse.Low.Base.validator p ->
p32: LowParse.Low.Base.leaf_reader p ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
v_payload:
(k: LowParse.Spec.Sum.sum_repr_type t
-> LowParse.Low.Sum.validate_sum_aux_payload_t t
pc
(LowParse.Spec.Enum.maybe_enum_key_of_repr (LowParse.Spec.Sum.sum_enum t) k))
-> LowParse.Low.Base.validator (LowParse.Spec.Sum.parse_sum t p pc) | {
"end_col": 5,
"end_line": 161,
"start_col": 2,
"start_line": 140
} |
Prims.Tot | val gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Known k))
(dsnd (f k))
(clens_dsum_cases_payload t (Known k))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (gaccessor (parse_dsum_cases' t f g (Known k)) (dsnd (f k)) (clens_dsum_cases_payload t (Known k)))
= synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ();
gaccessor_ext
(gaccessor_synth (dsnd (f k)) (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ())
(clens_dsum_cases_payload t (Known k))
() | val gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Known k))
(dsnd (f k))
(clens_dsum_cases_payload t (Known k)))
let gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Known k))
(dsnd (f k))
(clens_dsum_cases_payload t (Known k))) = | false | null | false | synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k))
(synth_dsum_case_recip t (Known k))
();
gaccessor_ext (gaccessor_synth (dsnd (f k))
(synth_dsum_case t (Known k))
(synth_dsum_case_recip t (Known k))
())
(clens_dsum_cases_payload t (Known k))
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Low.Base.Spec.gaccessor_ext",
"Prims.__proj__Mkdtuple2__item___1",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Combinators.parse_synth",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Low.Combinators.clens_synth",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"LowParse.Low.Combinators.gaccessor_synth",
"LowParse.Low.Sum.clens_dsum_cases_payload",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } ))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_injective t p f g x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_no_lookahead t p f g x));
gaccessor_prop_equiv (parse_dsum t p f g) g (clens_dsum_unknown_payload t) (gaccessor_clens_dsum_unknown_payload' t p f g);
gaccessor_clens_dsum_unknown_payload' t p f g
inline_for_extraction
let accessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_unknown_payload t).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_unknown_payload t p f g) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_unknown_payload t p f g) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p { kt.parser_kind_subkind == Some ParserStrong })
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_clens_dsum_unknown_payload t p f g))
= fun #rrel #rel -> accessor_clens_dsum_unknown_payload' t j f g #rrel #rel
let clens_dsum_cases_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_cases s k) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_cases s k) -> True);
clens_get = (fun (x: dsum_cases s k) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Known k))
(dsnd (f k))
(clens_dsum_cases_payload t (Known k))) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_cases_known_payload | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Sum.parse_dsum_cases' t
f
g
(LowParse.Spec.Enum.Known k))
(FStar.Pervasives.dsnd (f k))
(LowParse.Low.Sum.clens_dsum_cases_payload t (LowParse.Spec.Enum.Known k)) | {
"end_col": 6,
"end_line": 2102,
"start_col": 2,
"start_line": 2096
} |
Prims.Tot | val gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Unknown k)) g (clens_dsum_cases_payload t (Unknown k))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t)
: Tot (gaccessor (parse_dsum_cases' t f g (Unknown k)) g (clens_dsum_cases_payload t (Unknown k)))
= synth_dsum_case_injective t (Unknown k);
synth_dsum_case_inverse t (Unknown k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Unknown k)) (synth_dsum_case_recip t (Unknown k)) ();
gaccessor_ext
(gaccessor_synth g (synth_dsum_case t (Unknown k)) (synth_dsum_case_recip t (Unknown k)) ())
(clens_dsum_cases_payload t (Unknown k))
() | val gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Unknown k)) g (clens_dsum_cases_payload t (Unknown k)))
let gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Unknown k)) g (clens_dsum_cases_payload t (Unknown k))) = | false | null | false | synth_dsum_case_injective t (Unknown k);
synth_dsum_case_inverse t (Unknown k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Unknown k))
(synth_dsum_case_recip t (Unknown k))
();
gaccessor_ext (gaccessor_synth g
(synth_dsum_case t (Unknown k))
(synth_dsum_case_recip t (Unknown k))
())
(clens_dsum_cases_payload t (Unknown k))
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_unknown_key",
"LowParse.Low.Base.Spec.gaccessor_ext",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Enum.Unknown",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Low.Combinators.clens_synth",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"LowParse.Low.Combinators.gaccessor_synth",
"LowParse.Low.Sum.clens_dsum_cases_payload",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } ))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_injective t p f g x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_no_lookahead t p f g x));
gaccessor_prop_equiv (parse_dsum t p f g) g (clens_dsum_unknown_payload t) (gaccessor_clens_dsum_unknown_payload' t p f g);
gaccessor_clens_dsum_unknown_payload' t p f g
inline_for_extraction
let accessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_unknown_payload t).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_unknown_payload t p f g) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_unknown_payload t p f g) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p { kt.parser_kind_subkind == Some ParserStrong })
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_clens_dsum_unknown_payload t p f g))
= fun #rrel #rel -> accessor_clens_dsum_unknown_payload' t j f g #rrel #rel
let clens_dsum_cases_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_cases s k) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_cases s k) -> True);
clens_get = (fun (x: dsum_cases s k) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (gaccessor (parse_dsum_cases' t f g (Known k)) (dsnd (f k)) (clens_dsum_cases_payload t (Known k)))
= synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ();
gaccessor_ext
(gaccessor_synth (dsnd (f k)) (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ())
(clens_dsum_cases_payload t (Known k))
()
inline_for_extraction
let accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k))
= [@inline_let]
let _ =
synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ()
in
accessor_ext
(accessor_synth (dsnd (f k)) (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ())
(clens_dsum_cases_payload t (Known k))
()
let gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_cases_unknown_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_unknown_key t)
: Tot
(gaccessor (parse_dsum_cases' t f g (Unknown k)) g (clens_dsum_cases_payload t (Unknown k))) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_cases_unknown_payload | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_unknown_key t
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Sum.parse_dsum_cases' t
f
g
(LowParse.Spec.Enum.Unknown k))
g
(LowParse.Low.Sum.clens_dsum_cases_payload t (LowParse.Spec.Enum.Unknown k)) | {
"end_col": 6,
"end_line": 2136,
"start_col": 2,
"start_line": 2130
} |
Prims.Tot | val accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k))
= [@inline_let]
let _ =
synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ()
in
accessor_ext
(accessor_synth (dsnd (f k)) (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ())
(clens_dsum_cases_payload t (Known k))
() | val accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k))
let accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k)) = | false | null | false | [@@ inline_let ]let _ =
synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k))
(synth_dsum_case_recip t (Known k))
()
in
accessor_ext (accessor_synth (dsnd (f k))
(synth_dsum_case t (Known k))
(synth_dsum_case_recip t (Known k))
())
(clens_dsum_cases_payload t (Known k))
() | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Low.Base.accessor_ext",
"Prims.__proj__Mkdtuple2__item___1",
"LowParse.Spec.Sum.dsum_cases",
"LowParse.Spec.Enum.Known",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Combinators.parse_synth",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Low.Combinators.clens_synth",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"LowParse.Low.Combinators.gaccessor_synth",
"LowParse.Low.Combinators.accessor_synth",
"LowParse.Low.Sum.clens_dsum_cases_payload",
"Prims.squash",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"Prims.unit",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Low.Base.accessor",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.parse_dsum_cases'",
"LowParse.Low.Sum.gaccessor_clens_dsum_cases_known_payload"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } ))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_injective t p f g x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_unknown_payload_no_lookahead t p f g x));
gaccessor_prop_equiv (parse_dsum t p f g) g (clens_dsum_unknown_payload t) (gaccessor_clens_dsum_unknown_payload' t p f g);
gaccessor_clens_dsum_unknown_payload' t p f g
inline_for_extraction
let accessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_unknown_payload t).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_unknown_payload t p f g) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_unknown_payload t p f g) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_unknown_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p { kt.parser_kind_subkind == Some ParserStrong })
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_clens_dsum_unknown_payload t p f g))
= fun #rrel #rel -> accessor_clens_dsum_unknown_payload' t j f g #rrel #rel
let clens_dsum_cases_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_cases s k) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_cases s k) -> True);
clens_get = (fun (x: dsum_cases s k) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (gaccessor (parse_dsum_cases' t f g (Known k)) (dsnd (f k)) (clens_dsum_cases_payload t (Known k)))
= synth_dsum_case_injective t (Known k);
synth_dsum_case_inverse t (Known k);
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ();
gaccessor_ext
(gaccessor_synth (dsnd (f k)) (synth_dsum_case t (Known k)) (synth_dsum_case_recip t (Known k)) ())
(clens_dsum_cases_payload t (Known k))
()
inline_for_extraction
let accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val accessor_clens_dsum_cases_known_payload
(t: dsum)
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (accessor (gaccessor_clens_dsum_cases_known_payload t f g k)) | [] | LowParse.Low.Sum.accessor_clens_dsum_cases_known_payload | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_known_key t
-> LowParse.Low.Base.accessor (LowParse.Low.Sum.gaccessor_clens_dsum_cases_known_payload t f g k) | {
"end_col": 6,
"end_line": 2121,
"start_col": 2,
"start_line": 2112
} |
Prims.Tot | val gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } )) | val gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t)) = | false | null | false | fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k)
(synth_dsum_case_recip t k)
();
(consumed)
| _ -> (0)
in
(res <: (res: _{gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res})) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Bytes.bytes",
"Prims.nat",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Low.Sum.clens_dsum_unknown_payload",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Spec.Sum.dsum_tag_of_data",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Sum.synth_dsum_case_recip",
"LowParse.Spec.Sum.synth_dsum_case_injective",
"LowParse.Spec.Sum.synth_dsum_case_inverse",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Enum.maybe_enum_key_of_repr",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Sum.parse_dsum_eq3",
"LowParse.Low.Base.Spec.gaccessor'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t)) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t)
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Sum.parse_dsum t p f g)
g
(LowParse.Low.Sum.clens_dsum_unknown_payload t) | {
"end_col": 105,
"end_line": 1975,
"start_col": 2,
"start_line": 1963
} |
FStar.Pervasives.Lemma | val gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl'))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) = | false | null | true | parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq3",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Sum.clens_dsum_unknown_payload",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } ))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload_injective | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
g
(LowParse.Low.Sum.clens_dsum_unknown_payload t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
g
(LowParse.Low.Sum.clens_dsum_unknown_payload t)
sl' /\ LowParse.Spec.Base.injective_precond (LowParse.Spec.Sum.parse_dsum t p f g) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload' t p f g sl ==
LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload' t p f g sl') | {
"end_col": 26,
"end_line": 1995,
"start_col": 2,
"start_line": 1992
} |
Prims.Tot | val read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: (x: sum_key t -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos' | val read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: (x: sum_key t -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: (x: sum_key t -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc)) = | false | null | false | fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos';
read_sum_cases t pc pc32 destr k input pos' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Low.Base.leaf_reader",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.sum_key_type",
"LowParse.Spec.Sum.sum_enum",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Spec.Enum.dep_enum_destr",
"LowParse.Low.Sum.read_sum_cases_t",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Sum.read_sum_cases",
"LowParse.Spec.Sum.sum_cases",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"FStar.Pervasives.dfst",
"LowParse.Spec.Sum.parse_sum_cases'",
"LowParse.Spec.Sum.sum_type",
"LowParse.Low.Enum.jump_enum_key",
"LowParse.Spec.Sum.parse_sum_eq'",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.parse_sum",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: (x: sum_key t -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc)) | [] | LowParse.Low.Sum.read_sum | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
p32:
LowParse.Low.Base.leaf_reader (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t)) ->
j: LowParse.Low.Base.jumper p ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
pc32:
(x: LowParse.Spec.Sum.sum_key t
-> LowParse.Low.Base.leaf_reader (FStar.Pervasives.dsnd (pc x))) ->
destr:
LowParse.Spec.Enum.dep_enum_destr (LowParse.Spec.Sum.sum_enum t)
(LowParse.Low.Sum.read_sum_cases_t t pc)
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Sum.parse_sum t p pc) | {
"end_col": 47,
"end_line": 662,
"start_col": 2,
"start_line": 654
} |
FStar.Pervasives.Lemma | val gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl'))
let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) = | false | null | true | parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq3",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Sum.clens_dsum_unknown_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_injective t p f g k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_dsum_payload_no_lookahead t p f g k x));
gaccessor_prop_equiv (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) (gaccessor_clens_dsum_payload' t p f g k);
gaccessor_clens_dsum_payload' t p f g k
inline_for_extraction
let accessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_dsum t p f g) h input pos /\
(clens_dsum_payload t k).clens_cond (contents (parse_dsum t p f g) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_dsum_payload t p f g k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_dsum t p f g) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_dsum_payload t p f g k) input pos;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq3 t p f g large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_dsum_payload
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (accessor (gaccessor_clens_dsum_payload t p f g k))
= fun #rrel #rel -> accessor_clens_dsum_payload' t j f g k #rrel #rel
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_unknown_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor' (parse_dsum t p f g) g (clens_dsum_unknown_payload t))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (tg, consumed) ->
let k = maybe_enum_key_of_repr (dsum_enum t) tg in
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) g (clens_dsum_unknown_payload t) input res } ))
let gaccessor_clens_dsum_unknown_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl'))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (gaccessor_clens_dsum_unknown_payload' t p f g sl == gaccessor_clens_dsum_unknown_payload' t p f g sl')) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_unknown_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl /\
gaccessor_pre (parse_dsum t p f g) g (clens_dsum_unknown_payload t) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_unknown_payload' t p f g sl ==
gaccessor_clens_dsum_unknown_payload' t p f g sl')) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload_no_lookahead | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Sum.parse_dsum_kind kt t f ku) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
g
(LowParse.Low.Sum.clens_dsum_unknown_payload t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
g
(LowParse.Low.Sum.clens_dsum_unknown_payload t)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.Sum.parse_dsum t p f g) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload' t p f g sl ==
LowParse.Low.Sum.gaccessor_clens_dsum_unknown_payload' t p f g sl') | {
"end_col": 26,
"end_line": 2017,
"start_col": 2,
"start_line": 2014
} |
FStar.Pervasives.Lemma | val valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload | val valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)))))
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))))) = | false | null | true | valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"Prims.unit",
"LowParse.Low.Base.Spec.contents",
"LowParse.Spec.Sum.parse_dsum_eq",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.b2t",
"LowParse.Spec.Enum.uu___is_Known",
"LowParse.Spec.Sum.dsum_tag_of_data",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Known",
"Prims.logical",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
)))) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))))
(ensures
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))))) | [] | LowParse.Low.Sum.valid_dsum_elim_known | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.Sum.parse_dsum t p f g) h input pos /\
Known? (LowParse.Spec.Sum.dsum_tag_of_data t
(LowParse.Low.Base.Spec.contents (LowParse.Spec.Sum.parse_dsum t p f g) h input pos)))
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos /\
(let k' =
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos
in
let pos_payload =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos
in
Known? k' /\
(let _ = k' in
(let LowParse.Spec.Enum.Known #_ #_ #_ k = _ in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (f k)) h input pos_payload /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Sum.parse_dsum t p f g)
h
input
pos
(LowParse.Spec.Sum.synth_dsum_case t
(LowParse.Spec.Enum.Known k)
(LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (f k))
h
input
pos_payload))
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (f k))
h
input
pos_payload))
<:
Prims.logical))) | {
"end_col": 46,
"end_line": 1334,
"start_col": 2,
"start_line": 1329
} |
FStar.Pervasives.Lemma | val gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) = | false | null | true | parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl';
parse_strong_prefix (parse_sum t p pc) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"LowParse.Spec.Sum.parse_sum_eq''",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Sum.clens_sum_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_sum_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) | [] | LowParse.Low.Sum.gaccessor_clens_sum_payload_no_lookahead | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
k: LowParse.Spec.Sum.sum_key t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Sum.parse_sum_kind kt t pc) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_sum t p pc)
(FStar.Pervasives.dsnd (pc k))
(LowParse.Low.Sum.clens_sum_payload t k)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_sum t p pc)
(FStar.Pervasives.dsnd (pc k))
(LowParse.Low.Sum.clens_sum_payload t k)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.Sum.parse_sum t p pc) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_sum_payload' t p pc k sl ==
LowParse.Low.Sum.gaccessor_clens_sum_payload' t p pc k sl') | {
"end_col": 26,
"end_line": 857,
"start_col": 2,
"start_line": 854
} |
FStar.Pervasives.Lemma | val valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k))
h
input
(get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)))))
(ensures
(let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos) | val valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k))
h
input
(get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)))))
(ensures
(let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)))
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k))
h
input
(get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)))))
(ensures
(let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) = | false | null | true | valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.dsum_key_type",
"LowParse.Spec.Sum.dsum_enum",
"LowParse.Spec.Sum.parse_dsum_eq",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Enum.maybe_enum_key",
"LowParse.Spec.Enum.parse_maybe_enum_key",
"LowParse.Low.Base.Spec.contents",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.b2t",
"LowParse.Spec.Enum.uu___is_Known",
"Prims.logical",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Sum.synth_dsum_case",
"LowParse.Spec.Enum.Known",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 8,
"max_fuel": 2,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
(let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\
(let Known k = k' in
valid (dsnd (f k))
h
input
(get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)))))
(ensures
(let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos (parse_dsum t p f g)
h
input
pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload))) | [] | LowParse.Low.Sum.valid_dsum_intro_known | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos /\
(let k' =
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos
in
Known? k' /\
(let _ = k' in
(let LowParse.Spec.Enum.Known #_ #_ #_ k = _ in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (f k))
h
input
(LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos))
<:
Prims.logical)))
(ensures
(let _ =
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos
in
(let LowParse.Spec.Enum.Known #_ #_ #_ k = _ in
let pos_payload =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Enum.parse_maybe_enum_key p
(LowParse.Spec.Sum.dsum_enum t))
h
input
pos
in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Sum.parse_dsum t p f g)
h
input
pos
(LowParse.Spec.Sum.synth_dsum_case t
(LowParse.Spec.Enum.Known k)
(LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (f k)) h input pos_payload
))
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (f k))
h
input
pos_payload))
<:
Type0)) | {
"end_col": 57,
"end_line": 1131,
"start_col": 2,
"start_line": 1126
} |
FStar.Pervasives.Lemma | val valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_enum_key p (sum_enum t)) h input pos /\
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos))
))
(ensures
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos (parse_sum t p pc)
h
input
pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload))) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos) | val valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_enum_key p (sum_enum t)) h input pos /\
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos))
))
(ensures
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos (parse_sum t p pc)
h
input
pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)))
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_enum_key p (sum_enum t)) h input pos /\
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos))
))
(ensures
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos (parse_sum t p pc)
h
input
pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload))) = | false | null | true | valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Sum.parse_sum_eq",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Enum.enum_key",
"LowParse.Spec.Sum.sum_key_type",
"LowParse.Spec.Sum.sum_enum",
"LowParse.Spec.Enum.parse_enum_key",
"LowParse.Low.Base.Spec.contents",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Sum.synth_sum_case",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 8,
"max_fuel": 2,
"max_ifuel": 8,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": false,
"z3rlimit": 256,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(valid (parse_enum_key p (sum_enum t)) h input pos /\
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos))
))
(ensures
(let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos (parse_sum t p pc)
h
input
pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload))) | [] | LowParse.Low.Sum.valid_sum_intro | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t))
h
input
pos /\
(let k =
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t))
h
input
pos
in
LowParse.Low.Base.Spec.valid (FStar.Pervasives.dsnd (pc k))
h
input
(LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t))
h
input
pos)))
(ensures
(let k =
LowParse.Low.Base.Spec.contents (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t))
h
input
pos
in
let pos_payload =
LowParse.Low.Base.Spec.get_valid_pos (LowParse.Spec.Enum.parse_enum_key p
(LowParse.Spec.Sum.sum_enum t))
h
input
pos
in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Sum.parse_sum t p pc)
h
input
pos
(LowParse.Spec.Sum.synth_sum_case t
k
(LowParse.Low.Base.Spec.contents (FStar.Pervasives.dsnd (pc k)) h input pos_payload)
)
(LowParse.Low.Base.Spec.get_valid_pos (FStar.Pervasives.dsnd (pc k)) h input pos_payload
))) | {
"end_col": 55,
"end_line": 237,
"start_col": 2,
"start_line": 232
} |
FStar.Pervasives.Lemma | val gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
= parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'))
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) = | false | null | true | parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_strong_prefix (parse_dsum t p f g) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq3",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.parse_dsum_type_of_tag'",
"LowParse.Low.Sum.clens_dsum_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_dsum_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
no_lookahead_on_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl' | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_payload_no_lookahead
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
((parse_dsum_kind kt t f ku).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ no_lookahead_on_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_payload_no_lookahead | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_key t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Sum.parse_dsum_kind kt t f ku) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
(LowParse.Spec.Sum.parse_dsum_type_of_tag' t f g k)
(LowParse.Low.Sum.clens_dsum_payload t k)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
(LowParse.Spec.Sum.parse_dsum_type_of_tag' t f g k)
(LowParse.Low.Sum.clens_dsum_payload t k)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.Sum.parse_dsum t p f g) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_dsum_payload' t p f g k sl ==
LowParse.Low.Sum.gaccessor_clens_dsum_payload' t p f g k sl') | {
"end_col": 26,
"end_line": 1887,
"start_col": 2,
"start_line": 1884
} |
FStar.Pervasives.Lemma | val gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
))
=
parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) = | false | null | true | parse_dsum_eq3 t p f g sl;
parse_dsum_eq3 t p f g sl';
parse_injective (parse_dsum t p f g) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Sum.dsum",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.dsum_repr_type",
"LowParse.Spec.Sum.dsum_known_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.dsum_type_of_known_tag",
"LowParse.Spec.Sum.dsum_type_of_unknown_tag",
"LowParse.Spec.Sum.dsum_key",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Sum.parse_dsum_kind",
"LowParse.Spec.Sum.dsum_type",
"LowParse.Spec.Sum.parse_dsum",
"LowParse.Spec.Sum.parse_dsum_eq3",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Sum.parse_dsum_cases_kind",
"LowParse.Spec.Sum.dsum_type_of_tag",
"LowParse.Spec.Sum.parse_dsum_type_of_tag'",
"LowParse.Low.Sum.clens_dsum_payload",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_dsum_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
#pop-options
let gaccessor_clens_sum_payload_no_lookahead
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
(parse_sum_kind kt t pc).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
no_lookahead_on_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_strong_prefix (parse_sum t p pc) sl sl' ;
parse_injective p sl sl'
let gaccessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_injective t p pc k x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_clens_sum_payload_no_lookahead t p pc k x));
gaccessor_prop_equiv (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) (gaccessor_clens_sum_payload' t p pc k);
gaccessor_clens_sum_payload' t p pc k
inline_for_extraction
let accessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
valid (parse_sum t p pc) h input pos /\
(clens_sum_payload t k).clens_cond (contents (parse_sum t p pc) h input pos)
))
(ensures (fun h pos' h' ->
B.modifies B.loc_none h h' /\
pos' == slice_access h (gaccessor_clens_sum_payload t p pc k) input pos
))
=
let h = HST.get () in
[@inline_let]
let _ =
let pos' = get_valid_pos (parse_sum t p pc) h input pos in
let large = bytes_of_slice_from h input pos in
slice_access_eq h (gaccessor_clens_sum_payload t p pc k) input pos;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq'' t p pc large;
valid_facts p h input pos
in
j input pos
#pop-options
inline_for_extraction
let accessor_clens_sum_payload
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_payload t p pc k))
= fun #rrel #rel -> accessor_clens_sum_payload' t j pc k #rrel #rel
let clens_sum_cases_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_cases s k) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_cases s k) -> True);
clens_get = (fun (x: sum_cases s k) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (True)) (ensures (fun _ -> True)));
}
let gaccessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor (parse_sum_cases' t pc k) (dsnd (pc k)) (clens_sum_cases_payload t k))
= synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
gaccessor_ext
(gaccessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let accessor_clens_sum_cases_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (accessor (gaccessor_clens_sum_cases_payload t pc k))
= [@inline_let]
let _ =
synth_sum_case_injective t k;
synth_sum_case_inverse t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ()
in
accessor_ext
(accessor_synth (dsnd (pc k)) (synth_sum_case t k) (synth_sum_case_recip t k) ())
(clens_sum_cases_payload t k)
()
inline_for_extraction
let validate_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= validator (parse_dsum_cases' s f g x)
let validate_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : validate_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let validate_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (validate_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (validate_dsum_cases_t s f g x)))
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: validate_dsum_cases_t s f g x) input len
else (iff () <: validate_dsum_cases_t s f g x) input len
inline_for_extraction
let validate_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (validate_dsum_cases_eq s f g x))
= validate_dsum_cases_if' s f g x
inline_for_extraction
let validate_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= [@inline_let]
let _ = synth_dsum_case_injective s x in
match x with
| Known x' -> validate_synth (f' x') (synth_dsum_case s (Known x')) () <: validator (parse_dsum_cases' s f g x)
| Unknown x' -> validate_synth g' (synth_dsum_case s (Unknown x')) () <: validator (parse_dsum_cases' s f g x)
inline_for_extraction
let validate_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validate_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> validate_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> validate_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> validate_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let validate_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (validator (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : validator g)
(destr: dep_enum_destr _ (fun k -> validate_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (validator (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input (uint64_to_uint32 pos);
valid_facts (parse_dsum_cases s f g x) h input (uint64_to_uint32 pos);
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input (uint64_to_uint32 pos))
in
validate_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 40"
inline_for_extraction
let validate_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (validator (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: validator g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (validate_dsum_cases_t t f g))
: Tot (validator (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let pos_after_tag = v input pos in
if is_error pos_after_tag
then pos_after_tag
else
let tg = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input (uint64_to_uint32 pos_after_tag) in
destr (validate_dsum_cases_eq t f g) (validate_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
#reset-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
let valid_dsum_intro_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
))))
(ensures (
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
let valid_dsum_intro_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\
valid g h input (get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos)
)))
(ensures (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))
= valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload;
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos)
#reset-options
inline_for_extraction
let finalize_dsum_case_known
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(destr: enum_repr_of_key'_t (dsum_enum t))
(k: dsum_known_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (f k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (dsum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload)) (get_valid_pos (dsnd (f k)) h input pos_payload)
))
= let pos1 = write_enum_key w (dsum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_enum_key p (dsum_enum t)) h input pos;
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let sq = bytes_of_slice_from h input pos in
parse_enum_key_eq p (dsum_enum t) sq;
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_known h t p f g input pos
in
()
inline_for_extraction
let finalize_dsum_case_unknown
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(r: unknown_enum_repr (dsum_enum t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length s r in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid g h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length s r in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_dsum t p f g) h' input pos (synth_dsum_case t (Unknown r) (contents g h input pos_payload)) (get_valid_pos g h input pos_payload)
))
= let pos1 = w r input pos in
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
valid_facts p h input pos;
let sq = bytes_of_slice_from h input pos in
parse_maybe_enum_key_eq p (dsum_enum t) sq;
valid_dsum_intro_unknown h t p f g input pos
in
()
let valid_dsum_elim_tag
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\
contents (parse_maybe_enum_key p (dsum_enum t)) h input pos == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let _ = parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_dsum t p f g) h input pos in
let _ = valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos in
()
inline_for_extraction
let read_dsum_tag
(t: dsum)
(#kt: parser_kind)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader p)
(destr: maybe_enum_destr_t (maybe_enum_key (dsum_enum t)) (dsum_enum t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (dsum_key t)
(requires (fun h ->
valid (parse_dsum t p f g) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_dsum_elim_tag h t p f g input pos in
read_maybe_enum_key p32 (dsum_enum t) destr input pos
#push-options "--z3rlimit 32"
let valid_dsum_elim_known
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Known? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Known? k' /\ (
let Known k = k' in
valid (dsnd (f k)) h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Known k) (contents (dsnd (f k)) h input pos_payload))
(get_valid_pos (dsnd (f k)) h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Known k = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts (dsnd (f k)) h input pos_payload
#pop-options
let valid_dsum_elim_unknown
(h: HS.mem)
(t: dsum)
(#kt: parser_kind)
(p: parser kt (dsum_repr_type t))
(f: ((x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_dsum t p f g) h input pos /\
Unknown? (dsum_tag_of_data t (contents (parse_dsum t p f g) h input pos))
))
(ensures (
valid (parse_maybe_enum_key p (dsum_enum t)) h input pos /\ (
let k' = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
Unknown? k' /\ (
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid g h input pos_payload /\
valid_content_pos
(parse_dsum t p f g) h input pos
(synth_dsum_case t (Unknown r) (contents g h input pos_payload))
(get_valid_pos g h input pos_payload)
))))
=
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let Unknown r = contents (parse_maybe_enum_key p (dsum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_maybe_enum_key p (dsum_enum t)) h input pos in
valid_facts g h input pos_payload
inline_for_extraction
let jump_dsum_cases_t
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot Type
= jumper (parse_dsum_cases' s f g x)
let jump_dsum_cases_eq
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(v1 v2 : jump_dsum_cases_t s f g x)
: GTot Type0
= True
inline_for_extraction
let jump_dsum_cases_if'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
(cond: bool)
(ift: (cond_true cond -> Tot (jump_dsum_cases_t s f g x)))
(iff: (cond_false cond -> Tot (jump_dsum_cases_t s f g x)))
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input len ->
if cond
then (ift () <: jump_dsum_cases_t s f g x) input len
else (iff () <: jump_dsum_cases_t s f g x) input len
inline_for_extraction
let jump_dsum_cases_if
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(#k: parser_kind)
(g: parser k (dsum_type_of_unknown_tag s))
(x: dsum_key s)
: Tot (if_combinator _ (jump_dsum_cases_eq s f g x))
= jump_dsum_cases_if' s f g x
inline_for_extraction
let jump_dsum_cases'
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= synth_dsum_case_injective s x;
match x with
| Known x' -> jump_synth (f' x') (synth_dsum_case s (Known x')) () <: jumper (parse_dsum_cases' s f g x)
| Unknown x' -> jump_synth g' (synth_dsum_case s (Unknown x')) () <: jumper (parse_dsum_cases' s f g x)
inline_for_extraction
let jump_dsum_cases'_destr
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jump_dsum_cases_t s f g x)
= fun #rrel #rel input pos ->
match x with
| Known k ->
destr
_
(fun k -> jump_dsum_cases_if s f g (Known k))
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> jump_dsum_cases' s f f' g' (Known k))
k
input
pos
| Unknown r -> jump_dsum_cases' s f f' g' (Unknown r) input pos
inline_for_extraction
let jump_dsum_cases
(s: dsum)
(f: (x: dsum_known_key s) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag s x)))
(f' : (x: dsum_known_key s) -> Tot (jumper (dsnd (f x))))
(#k: parser_kind)
(#g: parser k (dsum_type_of_unknown_tag s))
(g' : jumper g)
(destr: dep_enum_destr _ (fun k -> jump_dsum_cases_t s f g (Known k)))
(x: dsum_key s)
: Tot (jumper (parse_dsum_cases s f g x))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
valid_facts (parse_dsum_cases' s f g x) h input pos;
valid_facts (parse_dsum_cases s f g x) h input pos;
parse_dsum_cases_eq' s f g x (bytes_of_slice_from h input pos)
in
jump_dsum_cases'_destr s f f' g' destr x input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let jump_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (jumper (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: jumper g)
(destr: dep_maybe_enum_destr_t (dsum_enum t) (jump_dsum_cases_t t f g))
: Tot (jumper (parse_dsum t p f g))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_dsum_eq' t p f g (bytes_of_slice_from h input pos) in
[@inline_let]
let _ = valid_facts (parse_dsum t p f g) h input pos in
[@inline_let]
let _ = valid_facts p h input pos in
let pos_after_tag = v input pos in
let tg = p32 input pos in
[@inline_let]
let _ = valid_facts (parse_dsum_cases' t f g (maybe_enum_key_of_repr (dsum_enum t) tg)) h input pos_after_tag in
destr (jump_dsum_cases_eq t f g) (jump_dsum_cases_if t f g) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_dsum_cases' t f f32 g32) tg input pos_after_tag
#pop-options
inline_for_extraction
let read_dsum_cases'
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #rrel #rel input pos ->
[@inline_let]
let _ = synth_dsum_case_injective t x in
match x with
| Known x' ->
read_synth'
(dsnd (f x'))
(synth_dsum_case t (Known x'))
(f32 x')
()
input
pos
| Unknown x' ->
read_synth'
g
(synth_dsum_case t (Unknown x'))
g32
()
input
pos
inline_for_extraction
let read_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot Type
= leaf_reader (parse_dsum_cases' t f g (Known k))
let read_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
(x y : read_dsum_cases_t t f g k)
: GTot Type0
= True
inline_for_extraction
let read_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(k: dsum_known_key t)
: Tot (if_combinator _ (read_dsum_cases_t_eq t f g k))
= fun cond (sv_true: cond_true cond -> Tot (read_dsum_cases_t t f g k)) (sv_false: cond_false cond -> Tot (read_dsum_cases_t t f g k)) #_ #_ input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let read_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
(x: dsum_key t)
: Tot (leaf_reader (parse_dsum_cases' t f g x))
= fun #_ #_ input pos ->
match x with
| Known k ->
destr
_
(read_dsum_cases_t_if t f g)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> read_dsum_cases' t f f32 g g32 (Known k))
k
input
pos
| Unknown r ->
read_dsum_cases' t f f32 g g32 (Unknown r) input pos
#push-options "--z3rlimit 16"
inline_for_extraction
let read_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(p32: leaf_reader (parse_maybe_enum_key p (dsum_enum t)))
(j: jumper p)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(f32: (x: dsum_known_key t) -> Tot (leaf_reader (dsnd (f x))))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(g32: leaf_reader g)
(destr: dep_enum_destr _ (read_dsum_cases_t t f g))
: Tot (leaf_reader (parse_dsum t p f g))
= fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_dsum t p f g) h input pos;
parse_dsum_eq_ t p f g (bytes_of_slice_from h input pos);
valid_facts (parse_maybe_enum_key p (dsum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_maybe_enum_key j (dsum_enum t) input pos in
valid_facts (parse_dsum_cases' t f g k) h input pos' ;
read_dsum_cases t f f32 g g32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_dsum_type_of_tag
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_type_of_tag t f sf g sg tg))
= match tg with
| Known x' -> serialize32_ext (dsnd (f x')) (sf x') (sf32 x') (parse_dsum_type_of_tag t f g tg) ()
| Unknown x' -> serialize32_ext g sg sg32 (parse_dsum_type_of_tag t f g tg) ()
inline_for_extraction
let serialize32_dsum_cases_aux
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= [@inline_let]
let _ = synth_dsum_case_injective t tg in
[@inline_let]
let _ = synth_dsum_case_inverse t tg in
serialize32_synth
(serialize32_dsum_type_of_tag t f sf sf32 sg32 tg)
(synth_dsum_case t tg)
(synth_dsum_case_recip t tg)
(fun x -> synth_dsum_case_recip t tg x)
()
inline_for_extraction
let serialize32_dsum_cases_t
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot Type
= serializer32 (serialize_dsum_cases t f sf g sg (Known k))
let serialize32_dsum_cases_t_eq
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
(x y: serialize32_dsum_cases_t t f sf g sg k)
: GTot Type0
= True
inline_for_extraction
let serialize32_dsum_cases_t_if
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(#k': parser_kind)
(g: parser k' (dsum_type_of_unknown_tag t))
(sg: serializer g)
(k: dsum_known_key t)
: Tot (if_combinator _ (serialize32_dsum_cases_t_eq t f sf g sg k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) (sv_false: (cond_false cond -> Tot (serialize32_dsum_cases_t t f sf g sg k))) x #rrel #rel output pos ->
if cond
then (sv_true () x output pos)
else (sv_false () x output pos)
inline_for_extraction
let serialize32_dsum_cases
(t: dsum)
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
(tg: dsum_key t)
: Tot (serializer32 (serialize_dsum_cases t f sf g sg tg))
= fun x #rrel #rel output pos ->
match tg with
| Known k ->
destr
_
(serialize32_dsum_cases_t_if t f sf g sg)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(fun k -> serialize32_dsum_cases_aux t f sf sf32 sg32 (Known k))
k
x
output
pos
| Unknown r ->
serialize32_dsum_cases_aux t f sf sf32 sg32 (Unknown r) x output pos
inline_for_extraction
let serialize32_dsum
(#kt: parser_kind)
(t: dsum)
(#p: parser kt (dsum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_maybe_enum_key _ s (dsum_enum t)))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(sf: (x: dsum_known_key t) -> Tot (serializer (dsnd (f x))))
(sf32: (x: dsum_known_key t) -> Tot (serializer32 (sf x)))
(#k': parser_kind)
(#g: parser k' (dsum_type_of_unknown_tag t))
(#sg: serializer g)
(sg32: serializer32 sg)
(destr: dep_enum_destr _ (serialize32_dsum_cases_t t f sf g sg))
: Tot (serializer32 (serialize_dsum t s f sf g sg))
= fun x #_ #_ output pos ->
[@inline_let]
let _ = serialize_dsum_eq' t s f sf g sg x in
let tg = dsum_tag_of_data t x in
serialize32_nondep_then_aux
s32
(serialize32_dsum_cases t f sf sf32 sg32 destr tg)
tg
x
output
pos
let clens_dsum_tag
(s: dsum)
: Tot (clens (dsum_type s) (dsum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = dsum_tag_of_data s;
}
let gaccessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (gaccessor (parse_dsum t p f g) (parse_maybe_enum_key p (dsum_enum t)) (clens_dsum_tag t))
= gaccessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
inline_for_extraction
let accessor_dsum_tag
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
: Tot (accessor (gaccessor_dsum_tag t p f g))
= accessor_tagged_union_tag
(parse_maybe_enum_key p (dsum_enum t))
(dsum_tag_of_data t)
(parse_dsum_cases t f g)
let clens_dsum_payload
(s: dsum)
(k: dsum_key s)
: Tot (clens (dsum_type s) (dsum_type_of_tag s k))
= {
clens_cond = (fun (x: dsum_type s) -> dsum_tag_of_data s x == k);
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s k x <: Ghost (dsum_type_of_tag s k) (requires (dsum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
let clens_dsum_unknown_payload
(s: dsum)
: Tot (clens (dsum_type s) (dsum_type_of_unknown_tag s))
= {
clens_cond = (fun (x: dsum_type s) -> Unknown? (dsum_tag_of_data s x));
clens_get = (fun (x: dsum_type s) -> synth_dsum_case_recip s (dsum_tag_of_data s x) x <: Ghost (dsum_type_of_unknown_tag s) (requires (Unknown? (dsum_tag_of_data s x))) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 16"
let gaccessor_clens_dsum_payload'
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
: Tot (gaccessor' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k))
= fun (input: bytes) ->
parse_dsum_eq3 t p f g input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_dsum_case_inverse t k;
synth_dsum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_dsum_case t k) (synth_dsum_case_recip t k) ();
(consumed)
| _ -> (0) // dummy
in
(res <: (res: _ { gaccessor_post' (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) input res } ))
let gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t) -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x)))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl /\
gaccessor_pre (parse_dsum t p f g) (parse_dsum_type_of_tag' t f g k) (clens_dsum_payload t k) sl' /\
injective_precond (parse_dsum t p f g) sl sl'
))
(ensures (
gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl'
)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 16,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_dsum_payload_injective
(#kt: parser_kind)
(t: dsum)
(p: parser kt (dsum_repr_type t))
(f: (x: dsum_known_key t -> Tot (k: parser_kind & parser k (dsum_type_of_known_tag t x))))
(#ku: parser_kind)
(g: parser ku (dsum_type_of_unknown_tag t))
(k: dsum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl /\
gaccessor_pre (parse_dsum t p f g)
(parse_dsum_type_of_tag' t f g k)
(clens_dsum_payload t k)
sl' /\ injective_precond (parse_dsum t p f g) sl sl'))
(ensures
(gaccessor_clens_dsum_payload' t p f g k sl == gaccessor_clens_dsum_payload' t p f g k sl')) | [] | LowParse.Low.Sum.gaccessor_clens_dsum_payload_injective | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.dsum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.dsum_repr_type t) ->
f:
(x: LowParse.Spec.Sum.dsum_known_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.dsum_type_of_known_tag t x))) ->
g: LowParse.Spec.Base.parser ku (LowParse.Spec.Sum.dsum_type_of_unknown_tag t) ->
k: LowParse.Spec.Sum.dsum_key t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
(LowParse.Spec.Sum.parse_dsum_type_of_tag' t f g k)
(LowParse.Low.Sum.clens_dsum_payload t k)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_dsum t p f g)
(LowParse.Spec.Sum.parse_dsum_type_of_tag' t f g k)
(LowParse.Low.Sum.clens_dsum_payload t k)
sl' /\ LowParse.Spec.Base.injective_precond (LowParse.Spec.Sum.parse_dsum t p f g) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_dsum_payload' t p f g k sl ==
LowParse.Low.Sum.gaccessor_clens_dsum_payload' t p f g k sl') | {
"end_col": 26,
"end_line": 1863,
"start_col": 2,
"start_line": 1860
} |
Prims.Tot | val gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k)) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } )) | val gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k)) = | false | null | false | fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k)
(synth_sum_case_recip t k)
();
(consumed)
| _ -> 0
in
(res
<:
(res: _{gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res})) | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"total"
] | [
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Bytes.bytes",
"Prims.nat",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Sum.clens_sum_payload",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"LowParse.Spec.Sum.sum_cases",
"LowParse.Spec.Sum.synth_sum_case",
"LowParse.Spec.Sum.synth_sum_case_recip",
"LowParse.Spec.Sum.synth_sum_case_injective",
"LowParse.Spec.Sum.synth_sum_case_inverse",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Sum.parse_sum_eq''",
"LowParse.Low.Base.Spec.gaccessor'"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k)) | [] | LowParse.Low.Sum.gaccessor_clens_sum_payload' | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
k: LowParse.Spec.Sum.sum_key t
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Sum.parse_sum t p pc)
(FStar.Pervasives.dsnd (pc k))
(LowParse.Low.Sum.clens_sum_payload t k) | {
"end_col": 108,
"end_line": 814,
"start_col": 2,
"start_line": 803
} |
FStar.Pervasives.Lemma | val gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) | [
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Sum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Enum",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
))
(ensures (gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
= parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl' ;
parse_injective (parse_sum t p pc) sl sl' ;
parse_injective p sl sl' | val gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl'))
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) = | false | null | true | parse_sum_eq'' t p pc sl;
parse_sum_eq'' t p pc sl';
parse_injective (parse_sum t p pc) sl sl';
parse_injective p sl sl' | {
"checked_file": "LowParse.Low.Sum.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Sum.fst.checked",
"LowParse.Low.Enum.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int.Cast.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Sum.fst"
} | [
"lemma"
] | [
"LowParse.Spec.Sum.sum",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Sum.sum_repr_type",
"LowParse.Spec.Sum.sum_key",
"Prims.dtuple2",
"LowParse.Spec.Sum.sum_type_of_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Sum.parse_sum_kind",
"LowParse.Spec.Sum.sum_type",
"LowParse.Spec.Sum.parse_sum",
"LowParse.Spec.Sum.parse_sum_eq''",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"Prims.__proj__Mkdtuple2__item___1",
"FStar.Pervasives.dsnd",
"LowParse.Low.Sum.clens_sum_payload",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Sum.gaccessor_clens_sum_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Sum
include LowParse.Low.Enum
include LowParse.Spec.Sum
module U32 = FStar.UInt32
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module Cast = FStar.Int.Cast
module U64 = FStar.UInt64
inline_for_extraction
let validate_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
validate_synth
(validate_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let validate_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= validator (parse_sum_cases t pc k)
let validate_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : validate_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let validate_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (validate_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (validate_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (validate_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let validate_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (validate_sum_cases_t t pc))
(k: sum_key t)
: Tot (validator (parse_sum_cases t pc k))
= destr
_
(validate_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(validate_sum_cases_aux t pc vc)
k
inline_for_extraction
let validate_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U64.t) ->
HST.Stack U64.t
(requires (fun h -> live_slice h input /\ U64.v pos <= U32.v input.len))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> is_error res
| Known k' ->
if is_success res
then
valid_pos (dsnd (pc k')) h input (uint64_to_uint32 pos) (uint64_to_uint32 res)
else
(~ (valid (dsnd (pc k')) h input (uint64_to_uint32 pos)))
)))
let validate_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k -> validate_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let validate_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (validate_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (validate_sum_aux_payload_t t pc k)))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: validate_sum_aux_payload_t t pc k) input pos
end else
(iff () <: validate_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let validate_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (validate_sum_aux_payload_eq t pc k))
= validate_sum_aux_payload_if' t pc k
#push-options "--z3rlimit 64 --z3cliopt smt.arith.nl=false --using_facts_from '* -FStar.Int.Cast -LowParse.BitFields'"
// --query_stats --smtencoding.elim_box true --smtencoding.l_arith_repr native --z3refresh"
inline_for_extraction
let validate_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (validator (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = parse_sum_eq'' t p pc (bytes_of_slice_from h input (uint64_to_uint32 pos)) in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p h input (uint64_to_uint32 pos) in
let len_after_tag = v input pos in
if is_error len_after_tag
then len_after_tag
else begin
let h1 = HST.get () in
let k' = p32 input (uint64_to_uint32 pos) in
[@inline_let]
let _ =
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input (uint64_to_uint32 len_after_tag)
| _ -> ()
in
v_payload k' input len_after_tag
end
#pop-options
inline_for_extraction
let validate_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (validate_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
// validate_synth (pc32 k) (synth_sum_case t k) () input pos
| _ -> validator_error_generic
inline_for_extraction
let validate_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (validate_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (validate_sum_aux_payload_eq t pc) (validate_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (validate_sum_aux_payload' t pc pc32) k
inline_for_extraction
let validate_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: validator p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (validator (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (validate_sum_aux_payload_t t pc))
: Tot (validator (parse_sum t p pc))
= validate_sum_aux t v p32 pc (validate_sum_aux_payload t pc pc32 destr)
module HS = FStar.HyperStack
#push-options "--z3rlimit 256 --z3cliopt smt.arith.nl=false --initial_ifuel 8 --max_ifuel 8 --initial_fuel 2 --max_fuel 2"
#restart-solver
let valid_sum_intro
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_enum_key p (sum_enum t)) h input pos /\ (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
valid (dsnd (pc k)) h input (get_valid_pos (parse_enum_key p (sum_enum t)) h input pos)
)))
(ensures (
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_content_pos
(parse_sum t p pc) h input pos
(synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload))
(get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = contents (parse_enum_key p (sum_enum t)) h input pos in
let pos_payload = get_valid_pos (parse_enum_key p (sum_enum t)) h input pos in
valid_facts (dsnd (pc k)) h input pos_payload;
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq t p pc (bytes_of_slice_from h input pos)
#pop-options
inline_for_extraction
let finalize_sum_case
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(s: serializer p)
(w: leaf_writer_strong s)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(destr: enum_repr_of_key'_t (sum_enum t))
(k: sum_key t)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack unit
(requires (fun h ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
U32.v pos + len_tag < 4294967296 /\ (
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
valid (dsnd (pc k)) h input pos_payload /\
writable input.base (U32.v pos) (U32.v pos_payload) h
)))
(ensures (fun h _ h' ->
let len_tag = serialized_length (serialize_enum_key _ s (sum_enum t)) k in
let pos_payload = pos `U32.add` U32.uint_to_t len_tag in
B.modifies (loc_slice_from_to input pos pos_payload) h h' /\
valid_content_pos (parse_sum t p pc) h' input pos (synth_sum_case t k (contents (dsnd (pc k)) h input pos_payload)) (get_valid_pos (dsnd (pc k)) h input pos_payload)
))
= let pos1 = write_enum_key w (sum_enum t) destr k input pos in
let h = HST.get () in
[@inline_let]
let _ = valid_sum_intro h t p pc input pos in
()
inline_for_extraction
let jump_sum_cases_aux
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
jump_synth
(jump_weaken
(weaken_parse_cases_kind t pc)
(vc k)
()
)
(synth_sum_case t k)
()
inline_for_extraction
let jump_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= jumper (parse_sum_cases t pc k)
let jump_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : jump_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let jump_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (jump_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (jump_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (jump_sum_cases_t t pc k)) #rrel #rel input pos ->
if cond
then sv_true () input pos
else sv_false () input pos
inline_for_extraction
let jump_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(vc: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (jump_sum_cases_t t pc))
(k: sum_key t)
: Tot (jumper (parse_sum_cases t pc k))
= destr
_
(jump_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(jump_sum_cases_aux t pc vc)
k
inline_for_extraction
let jump_sum_aux_payload_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot Type
= (#rrel: _) -> (#rel: _) ->
(input: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack U32.t
(requires (fun h -> live_slice h input /\ U32.v pos <= U32.v input.len /\ (
match k with
| Unknown _ -> False
| Known k' -> valid (dsnd (pc k')) h input pos
)))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\ (
match k with
| Unknown _ -> False
| Known k' ->
valid_pos (dsnd (pc k')) h input pos res
)))
let jump_sum_aux_payload_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k -> jump_sum_aux_payload_t t pc k -> GTot Type0)
= fun _ _ -> True
inline_for_extraction
let jump_sum_aux_payload_if'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
(cond: bool)
(ift: ((cond_true cond) -> Tot (jump_sum_aux_payload_t t pc k)))
(iff: ((cond_false cond) -> Tot (jump_sum_aux_payload_t t pc k)))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
if cond
then begin
(ift () <: jump_sum_aux_payload_t t pc k) input pos
end else
(iff () <: jump_sum_aux_payload_t t pc k) input pos
inline_for_extraction
let jump_sum_aux_payload_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: maybe_enum_key (sum_enum t))
: Tot (if_combinator _ (jump_sum_aux_payload_eq t pc k))
= jump_sum_aux_payload_if' t pc k
let parse_sum_eq3
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k)))
(ensures (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k)
| _ -> False
end
))
= parse_sum_eq'' t p pc input
let parse_sum_eq4
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(input: bytes)
(k' : sum_repr_type t)
(consumed_k: consumed_length input)
(consumed_payload: nat)
: Lemma
(requires (Some? (parse (parse_sum t p pc) input) /\ parse p input == Some (k', consumed_k) /\ (
let input_k = Seq.slice input consumed_k (Seq.length input) in
let k = maybe_enum_key_of_repr (sum_enum t) k' in
begin match k with
| Known k ->
Some? (parse (dsnd (pc k)) input_k) /\ (
let Some (_, consumed_payload') = parse (dsnd (pc k)) input_k in
consumed_payload' == consumed_payload
)
| _ -> False
end
)))
(ensures (
let Some (_, consumed) = parse (parse_sum t p pc) input in
consumed == consumed_k + consumed_payload
))
= parse_sum_eq'' t p pc input
#push-options "--z3rlimit 16"
let valid_sum_elim
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel: _) (#rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid p h input pos /\ (
let pos_payload = get_valid_pos p h input pos in
let k' = maybe_enum_key_of_repr (sum_enum t) (contents p h input pos) in
match k' with
| Known k ->
k == sum_tag_of_data t (contents (parse_sum t p pc) h input pos) /\
valid (dsnd (pc k)) h input pos_payload /\
valid_pos
(parse_sum t p pc) h input pos
(get_valid_pos (dsnd (pc k)) h input pos_payload)
| _ -> False
)))
= let sinput = bytes_of_slice_from h input pos in
let _ = parse_sum_eq'' t p pc sinput in
[@inline_let]
let _ = valid_facts (parse_sum t p pc) h input pos in
let Some (k', consumed_k) = parse p sinput in
let pos_after_tag = U32.uint_to_t (U32.v pos + consumed_k) in
[@inline_let]
let _ = valid_facts p h input pos in
assert (valid_content_pos p h input pos k' pos_after_tag);
match maybe_enum_key_of_repr (sum_enum t) k' with
| Known k -> valid_facts (dsnd (pc k)) h input pos_after_tag
| _ -> ()
#pop-options
let valid_sum_elim_tag
(h: HS.mem)
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid (parse_sum t p pc) h input pos
))
(ensures (
valid (parse_enum_key p (sum_enum t)) h input pos /\
contents (parse_enum_key p (sum_enum t)) h input pos == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let _ = parse_sum_eq' t p pc (bytes_of_slice_from h input pos) in
let _ = valid_facts (parse_sum t p pc) h input pos in
let _ = valid_facts (parse_enum_key p (sum_enum t)) h input pos in
()
inline_for_extraction
let read_sum_tag
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(p32: leaf_reader p)
(destr: dep_maybe_enum_destr_t (sum_enum t) (read_enum_key_t (sum_enum t)))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: HST.Stack (sum_key t)
(requires (fun h ->
valid (parse_sum t p pc) h input pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == sum_tag_of_data t (contents (parse_sum t p pc) h input pos)
))
= let h = HST.get () in
[@inline_let] let _ = valid_sum_elim_tag h t p pc input pos in
read_enum_key p32 (sum_enum t) destr input pos
inline_for_extraction
let jump_sum_aux
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(v_payload: ((k: sum_repr_type t)) -> Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k)))
: Tot (jumper (parse_sum t p pc))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_sum_elim h t p pc input pos in
let pos_after_tag = v input pos in
let k' = p32 input pos in
v_payload k' input pos_after_tag
inline_for_extraction
let jump_sum_aux_payload'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(k: maybe_enum_key (sum_enum t))
: Tot (jump_sum_aux_payload_t t pc k)
= fun #rrel #rel input pos ->
match k with
| Known k ->
[@inline_let]
let _ = synth_sum_case_injective t k in
pc32 k input pos
| _ -> 0ul // dummy, but we MUST NOT remove this branch, otherwise extraction fails
inline_for_extraction
let jump_sum_aux_payload
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
(k: sum_repr_type t)
: Tot (jump_sum_aux_payload_t t pc (maybe_enum_key_of_repr (sum_enum t) k))
= destr (jump_sum_aux_payload_eq t pc) (jump_sum_aux_payload_if t pc) (fun _ _ -> ()) (fun _ _ _ _ -> ()) (jump_sum_aux_payload' t pc pc32) k
inline_for_extraction
let jump_sum
(t: sum)
(#kt: parser_kind)
(#p: parser kt (sum_repr_type t))
(v: jumper p)
(p32: leaf_reader p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (jumper (dsnd (pc x)))))
(destr: dep_maybe_enum_destr_t (sum_enum t) (jump_sum_aux_payload_t t pc))
: Tot (jumper (parse_sum t p pc))
= jump_sum_aux t v p32 pc (jump_sum_aux_payload t pc pc32 destr)
inline_for_extraction
let read_sum_cases'
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= [@inline_let]
let _ = synth_sum_case_injective t k in
read_synth'
(dsnd (pc k))
(synth_sum_case t k)
(pc32 k)
()
inline_for_extraction
let read_sum_cases_t
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot Type
= leaf_reader (parse_sum_cases' t pc k)
let read_sum_cases_t_eq
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(x y : read_sum_cases_t t pc k)
: GTot Type0
= True
inline_for_extraction
let read_sum_cases_t_if
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (if_combinator _ (read_sum_cases_t_eq t pc k))
= fun cond (sv_true: cond_true cond -> Tot (read_sum_cases_t t pc k)) (sv_false: cond_false cond -> Tot (read_sum_cases_t t pc k)) #_ #_ input pos ->
if cond
then (sv_true () input pos)
else (sv_false () input pos)
inline_for_extraction
let read_sum_cases
(t: sum)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
(k: sum_key t)
: Tot (leaf_reader (parse_sum_cases' t pc k))
= destr
_
(read_sum_cases_t_if t pc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(read_sum_cases' t pc pc32)
k
#push-options "--z3rlimit 32"
inline_for_extraction
let read_sum
(#kt: parser_kind)
(t: sum)
(p: parser kt (sum_repr_type t))
(p32: leaf_reader (parse_enum_key p (sum_enum t)))
(j: jumper p)
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(pc32: ((x: sum_key t) -> Tot (leaf_reader (dsnd (pc x)))))
(destr: dep_enum_destr (sum_enum t) (read_sum_cases_t t pc))
: Tot (leaf_reader (parse_sum t p pc))
=
fun #_ #_ input pos ->
let h = HST.get () in
valid_facts (parse_sum t p pc) h input pos;
parse_sum_eq' t p pc (bytes_of_slice_from h input pos);
valid_facts (parse_enum_key p (sum_enum t)) h input pos;
let k = p32 input pos in
let pos' = jump_enum_key j (sum_enum t) input pos in
valid_facts (parse_sum_cases' t pc k) h input pos' ;
read_sum_cases t pc pc32 destr k input pos'
#pop-options
inline_for_extraction
let serialize32_sum_cases_t
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot Type
= serializer32 (serialize_sum_cases t pc sc k)
let serialize32_sum_cases_t_eq
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
(x y: serialize32_sum_cases_t t sc k)
: GTot Type0
= True
inline_for_extraction
let serialize32_sum_cases_t_if
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(k: sum_key t)
: Tot (if_combinator _ (serialize32_sum_cases_t_eq t sc k))
= fun cond (sv_true: (cond_true cond -> Tot (serialize32_sum_cases_t t sc k))) (sv_false: (cond_false cond -> Tot (serialize32_sum_cases_t t sc k))) x #rrel #rel b pos ->
if cond
then (sv_true () x b pos)
else (sv_false () x b pos)
inline_for_extraction
let serialize32_sum_cases_aux
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= fun x #rrel #rel b pos ->
[@inline_let] let _ =
Classical.forall_intro (parse_sum_cases_eq' t pc k);
synth_sum_case_injective t k;
synth_sum_case_inverse t k
in
serialize32_synth
(sc32 k)
(synth_sum_case t k)
(synth_sum_case_recip t k)
(fun x -> synth_sum_case_recip t k x)
()
x
b
pos
inline_for_extraction
let serialize32_sum_cases
(t: sum)
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
(k: sum_key t)
: Tot (serializer32 (serialize_sum_cases t pc sc k))
= destr
_
(serialize32_sum_cases_t_if t sc)
(fun _ _ -> ())
(fun _ _ _ _ -> ())
(serialize32_sum_cases_aux t sc sc32)
k
inline_for_extraction
let serialize32_sum
(#kt: parser_kind)
(t: sum)
(#p: parser kt (sum_repr_type t))
(s: serializer p {kt.parser_kind_subkind == Some ParserStrong})
(s32: serializer32 (serialize_enum_key _ s (sum_enum t)))
(#pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(sc: ((x: sum_key t) -> Tot (serializer (dsnd (pc x)))))
(sc32: ((x: sum_key t) -> Tot (serializer32 (sc x))))
(destr: dep_enum_destr (sum_enum t) (serialize32_sum_cases_t t sc))
: Tot (serializer32 (serialize_sum t s sc))
= fun x #rrel #rel b pos ->
serialize_sum_eq t s sc x;
let tg = sum_tag_of_data t x in
serialize32_nondep_then_aux s32 (serialize32_sum_cases t sc sc32 destr tg) tg x b pos
let clens_sum_tag
(s: sum)
: Tot (clens (sum_type s) (sum_key s))
= {
clens_cond = (fun _ -> True);
clens_get = sum_tag_of_data s;
}
let gaccessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (gaccessor (parse_sum t p pc) (parse_enum_key p (sum_enum t)) (clens_sum_tag t))
= gaccessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
inline_for_extraction
let accessor_sum_tag
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
: Tot (accessor (gaccessor_sum_tag t p pc))
= accessor_tagged_union_tag
(parse_enum_key p (sum_enum t))
(sum_tag_of_data t)
(parse_sum_cases t pc)
let clens_sum_payload
(s: sum)
(k: sum_key s)
: Tot (clens (sum_type s) (sum_type_of_tag s k))
= {
clens_cond = (fun (x: sum_type s) -> sum_tag_of_data s x == k);
clens_get = (fun (x: sum_type s) -> synth_sum_case_recip s k x <: Ghost (sum_type_of_tag s k) (requires (sum_tag_of_data s x == k)) (ensures (fun _ -> True)));
}
#push-options "--z3rlimit 32"
let gaccessor_clens_sum_payload'
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
: Tot (gaccessor' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k))
= fun (input: bytes) ->
parse_sum_eq'' t p pc input;
let res =
match parse p input with
| Some (_, consumed) ->
synth_sum_case_inverse t k;
synth_sum_case_injective t k;
synth_injective_synth_inverse_synth_inverse_recip (synth_sum_case t k) (synth_sum_case_recip t k) ();
(consumed)
| _ -> 0 // dummy
in
(res <: (res: _ { gaccessor_post' (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) input res } ))
#push-options "--z3rlimit 64"
let gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: ((x: sum_key t) -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'
)) | false | false | LowParse.Low.Sum.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_clens_sum_payload_injective
(t: sum)
(#kt: parser_kind)
(p: parser kt (sum_repr_type t))
(pc: (x: sum_key t -> Tot (k: parser_kind & parser k (sum_type_of_tag t x))))
(k: sum_key t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl /\
gaccessor_pre (parse_sum t p pc) (dsnd (pc k)) (clens_sum_payload t k) sl' /\
injective_precond (parse_sum t p pc) sl sl'))
(ensures
(gaccessor_clens_sum_payload' t p pc k sl == gaccessor_clens_sum_payload' t p pc k sl')) | [] | LowParse.Low.Sum.gaccessor_clens_sum_payload_injective | {
"file_name": "src/lowparse/LowParse.Low.Sum.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
t: LowParse.Spec.Sum.sum ->
p: LowParse.Spec.Base.parser kt (LowParse.Spec.Sum.sum_repr_type t) ->
pc:
(x: LowParse.Spec.Sum.sum_key t
-> Prims.dtuple2 LowParse.Spec.Base.parser_kind
(fun k -> LowParse.Spec.Base.parser k (LowParse.Spec.Sum.sum_type_of_tag t x))) ->
k: LowParse.Spec.Sum.sum_key t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_sum t p pc)
(FStar.Pervasives.dsnd (pc k))
(LowParse.Low.Sum.clens_sum_payload t k)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Sum.parse_sum t p pc)
(FStar.Pervasives.dsnd (pc k))
(LowParse.Low.Sum.clens_sum_payload t k)
sl' /\ LowParse.Spec.Base.injective_precond (LowParse.Spec.Sum.parse_sum t p pc) sl sl')
(ensures
LowParse.Low.Sum.gaccessor_clens_sum_payload' t p pc k sl ==
LowParse.Low.Sum.gaccessor_clens_sum_payload' t p pc k sl') | {
"end_col": 26,
"end_line": 835,
"start_col": 2,
"start_line": 832
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | let pow2_384 = | false | null | false | 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_384 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_384 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 121,
"end_line": 13,
"start_col": 22,
"start_line": 13
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | let pow2_512 = | false | null | false | 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_512 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_512 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 153,
"end_line": 17,
"start_col": 22,
"start_line": 17
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_192 = 0x1000000000000000000000000000000000000000000000000 | let pow2_192 = | false | null | false | 0x1000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_192 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_192 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 73,
"end_line": 7,
"start_col": 22,
"start_line": 7
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000 | let pow2_256 = | false | null | false | 0x10000000000000000000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_256 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_256 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 89,
"end_line": 9,
"start_col": 22,
"start_line": 9
} |
|
Prims.Tot | val prime:nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prime:nat = 57896044618658097711785492504343953926634992332820282019728792003956564819949 | val prime:nat
let prime:nat = | false | null | false | 57896044618658097711785492504343953926634992332820282019728792003956564819949 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5
let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6
let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7:nat) : nat = pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7
let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8:nat) : nat = pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val prime:nat | [] | Vale.Curve25519.Fast_defs.prime | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.nat | {
"end_col": 100,
"end_line": 29,
"start_col": 23,
"start_line": 29
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | let pow2_448 = | false | null | false | 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_448 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_448 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 137,
"end_line": 15,
"start_col": 22,
"start_line": 15
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000 | let pow2_320 = | false | null | false | 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_320 : Prims.int | [] | Vale.Curve25519.Fast_defs.pow2_320 | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 105,
"end_line": 11,
"start_col": 22,
"start_line": 11
} |
|
Prims.Tot | val bool_bit (b: bool) : bit | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bool_bit (b:bool) : bit = if b then 1 else 0 | val bool_bit (b: bool) : bit
let bool_bit (b: bool) : bit = | false | null | false | if b then 1 else 0 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.bool",
"Vale.Curve25519.Fast_defs.bit"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5
let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6
let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7:nat) : nat = pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7
let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8:nat) : nat = pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8
unfold let prime:nat = 57896044618658097711785492504343953926634992332820282019728792003956564819949 //(pow2 255) - 19
type bit = b:nat { b <= 1 } | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bool_bit (b: bool) : bit | [] | Vale.Curve25519.Fast_defs.bool_bit | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Prims.bool -> Vale.Curve25519.Fast_defs.bit | {
"end_col": 48,
"end_line": 33,
"start_col": 30,
"start_line": 33
} |
Prims.Tot | val pow2_five (c0 c1 c2 c3 c4: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4 | val pow2_five (c0 c1 c2 c3 c4: nat) : nat
let pow2_five (c0 c1 c2 c3 c4: nat) : nat = | false | null | false | pow2_four c0 c1 c2 c3 + pow2_256 * c4 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_four",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_256"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_five (c0 c1 c2 c3 c4: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_five | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c0: Prims.nat -> c1: Prims.nat -> c2: Prims.nat -> c3: Prims.nat -> c4: Prims.nat -> Prims.nat | {
"end_col": 80,
"end_line": 23,
"start_col": 43,
"start_line": 23
} |
Prims.Tot | val pow2_two (c0 c1: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1 | val pow2_two (c0 c1: nat) : nat
let pow2_two (c0 c1: nat) : nat = | false | null | false | c0 + pow2_64 * c1 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.pow2_64"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512) | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_two (c0 c1: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_two | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c0: Prims.nat -> c1: Prims.nat -> Prims.nat | {
"end_col": 50,
"end_line": 20,
"start_col": 33,
"start_line": 20
} |
Prims.Tot | val pow2_six (c0 c1 c2 c3 c4 c5: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5 | val pow2_six (c0 c1 c2 c3 c4 c5: nat) : nat
let pow2_six (c0 c1 c2 c3 c4 c5: nat) : nat = | false | null | false | pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_five",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_320"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_six (c0 c1 c2 c3 c4 c5: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_six | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c0: Prims.nat -> c1: Prims.nat -> c2: Prims.nat -> c3: Prims.nat -> c4: Prims.nat -> c5: Prims.nat
-> Prims.nat | {
"end_col": 85,
"end_line": 24,
"start_col": 45,
"start_line": 24
} |
Prims.Tot | val pow2_four (c0 c1 c2 c3: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3 | val pow2_four (c0 c1 c2 c3: nat) : nat
let pow2_four (c0 c1 c2 c3: nat) : nat = | false | null | false | pow2_three c0 c1 c2 + pow2_192 * c3 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_three",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_192"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_four (c0 c1 c2 c3: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_four | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c0: Prims.nat -> c1: Prims.nat -> c2: Prims.nat -> c3: Prims.nat -> Prims.nat | {
"end_col": 75,
"end_line": 22,
"start_col": 40,
"start_line": 22
} |
Prims.Tot | val pow2_three (c0 c1 c2: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2 | val pow2_three (c0 c1 c2: nat) : nat
let pow2_three (c0 c1 c2: nat) : nat = | false | null | false | pow2_two c0 c1 + pow2_128 * c2 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_two",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.pow2_128"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512) | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_three (c0 c1 c2: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_three | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | c0: Prims.nat -> c1: Prims.nat -> c2: Prims.nat -> Prims.nat | {
"end_col": 68,
"end_line": 21,
"start_col": 38,
"start_line": 21
} |
Prims.Tot | val mul_nats (x y: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_nats (x y:nat) : nat =
let prod = x * y in
Vale.Curve25519.Fast_lemmas_internal.lemma_mul_bounds_le 0 x 0 y;
prod | val mul_nats (x y: nat) : nat
let mul_nats (x y: nat) : nat = | false | null | false | let prod = x * y in
Vale.Curve25519.Fast_lemmas_internal.lemma_mul_bounds_le 0 x 0 y;
prod | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.unit",
"Vale.Curve25519.Fast_lemmas_internal.lemma_mul_bounds_le",
"Prims.int",
"FStar.Mul.op_Star"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5
let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6
let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7:nat) : nat = pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7
let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8:nat) : nat = pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8
unfold let prime:nat = 57896044618658097711785492504343953926634992332820282019728792003956564819949 //(pow2 255) - 19
type bit = b:nat { b <= 1 }
let bool_bit (b:bool) : bit = if b then 1 else 0 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_nats (x y: nat) : nat | [] | Vale.Curve25519.Fast_defs.mul_nats | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.nat -> y: Prims.nat -> Prims.nat | {
"end_col": 6,
"end_line": 38,
"start_col": 30,
"start_line": 35
} |
Prims.Tot | val pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8:nat) : nat = pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8 | val pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8: nat) : nat
let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8: nat) : nat = | false | null | false | pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_eight",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_512"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5
let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_nine | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c0: Prims.nat ->
c1: Prims.nat ->
c2: Prims.nat ->
c3: Prims.nat ->
c4: Prims.nat ->
c5: Prims.nat ->
c6: Prims.nat ->
c7: Prims.nat ->
c8: Prims.nat
-> Prims.nat | {
"end_col": 105,
"end_line": 27,
"start_col": 55,
"start_line": 27
} |
Prims.Tot | val pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7:nat) : nat = pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7 | val pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7: nat) : nat
let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7: nat) : nat = | false | null | false | pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_seven",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_448"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_eight | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c0: Prims.nat ->
c1: Prims.nat ->
c2: Prims.nat ->
c3: Prims.nat ->
c4: Prims.nat ->
c5: Prims.nat ->
c6: Prims.nat ->
c7: Prims.nat
-> Prims.nat | {
"end_col": 100,
"end_line": 26,
"start_col": 53,
"start_line": 26
} |
Prims.Tot | val pow2_seven (c0 c1 c2 c3 c4 c5 c6: nat) : nat | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6 | val pow2_seven (c0 c1 c2 c3 c4 c5 c6: nat) : nat
let pow2_seven (c0 c1 c2 c3 c4 c5 c6: nat) : nat = | false | null | false | pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6 | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.op_Addition",
"Vale.Curve25519.Fast_defs.pow2_six",
"FStar.Mul.op_Star",
"Vale.Curve25519.Fast_defs.pow2_384"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4 | false | true | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_seven (c0 c1 c2 c3 c4 c5 c6: nat) : nat | [] | Vale.Curve25519.Fast_defs.pow2_seven | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c0: Prims.nat ->
c1: Prims.nat ->
c2: Prims.nat ->
c3: Prims.nat ->
c4: Prims.nat ->
c5: Prims.nat ->
c6: Prims.nat
-> Prims.nat | {
"end_col": 92,
"end_line": 25,
"start_col": 50,
"start_line": 25
} |
Prims.Tot | val add_carry (x y: nat64) (c: bit) : nat64 & (c': nat{c = 0 || c = 1}) | [
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let add_carry (x y:nat64) (c:bit) : nat64 & (c':nat{c = 0 || c = 1})
=
add_wrap64 (add_wrap64 x y) c,
(if x + y + c >= pow2_64 then 1 else 0) | val add_carry (x y: nat64) (c: bit) : nat64 & (c': nat{c = 0 || c = 1})
let add_carry (x y: nat64) (c: bit) : nat64 & (c': nat{c = 0 || c = 1}) = | false | null | false | add_wrap64 (add_wrap64 x y) c, (if x + y + c >= pow2_64 then 1 else 0) | {
"checked_file": "Vale.Curve25519.Fast_defs.fst.checked",
"dependencies": [
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Curve25519.Fast_lemmas_internal.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Curve25519.Fast_defs.fst"
} | [
"total"
] | [
"Vale.Def.Types_s.nat64",
"Vale.Curve25519.Fast_defs.bit",
"FStar.Pervasives.Native.Mktuple2",
"Prims.nat",
"Prims.b2t",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"Vale.Arch.Types.add_wrap64",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"Vale.Def.Words_s.pow2_64",
"Prims.bool",
"FStar.Pervasives.Native.tuple2"
] | [] | module Vale.Curve25519.Fast_defs
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
unfold let pow2_192 = 0x1000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 192 = pow2_192)
unfold let pow2_256 = 0x10000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 256 = pow2_256)
unfold let pow2_320 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 320 = pow2_320)
unfold let pow2_384 = 0x1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 384 = pow2_384)
unfold let pow2_448 = 0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 448 = pow2_448)
unfold let pow2_512 = 0x100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
let _ = assert_norm (pow2 512 = pow2_512)
let pow2_two (c0 c1:nat) : nat = c0 + pow2_64 * c1
let pow2_three (c0 c1 c2:nat) : nat = pow2_two c0 c1 + pow2_128 * c2
let pow2_four (c0 c1 c2 c3:nat) : nat = pow2_three c0 c1 c2 + pow2_192 * c3
let pow2_five (c0 c1 c2 c3 c4:nat) : nat = pow2_four c0 c1 c2 c3 + pow2_256 * c4
let pow2_six (c0 c1 c2 c3 c4 c5:nat) : nat = pow2_five c0 c1 c2 c3 c4 + pow2_320 * c5
let pow2_seven (c0 c1 c2 c3 c4 c5 c6:nat) : nat = pow2_six c0 c1 c2 c3 c4 c5 + pow2_384 * c6
let pow2_eight (c0 c1 c2 c3 c4 c5 c6 c7:nat) : nat = pow2_seven c0 c1 c2 c3 c4 c5 c6 + pow2_448 * c7
let pow2_nine (c0 c1 c2 c3 c4 c5 c6 c7 c8:nat) : nat = pow2_eight c0 c1 c2 c3 c4 c5 c6 c7 + pow2_512 * c8
unfold let prime:nat = 57896044618658097711785492504343953926634992332820282019728792003956564819949 //(pow2 255) - 19
type bit = b:nat { b <= 1 }
let bool_bit (b:bool) : bit = if b then 1 else 0
let mul_nats (x y:nat) : nat =
let prod = x * y in
Vale.Curve25519.Fast_lemmas_internal.lemma_mul_bounds_le 0 x 0 y;
prod
open Vale.Arch.Types
let add_carry (x y:nat64) (c:bit) : nat64 & (c':nat{c = 0 || c = 1}) | false | false | Vale.Curve25519.Fast_defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val add_carry (x y: nat64) (c: bit) : nat64 & (c': nat{c = 0 || c = 1}) | [] | Vale.Curve25519.Fast_defs.add_carry | {
"file_name": "vale/code/crypto/ecc/curve25519/Vale.Curve25519.Fast_defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.nat64 -> y: Vale.Def.Types_s.nat64 -> c: Vale.Curve25519.Fast_defs.bit
-> Vale.Def.Types_s.nat64 * c': Prims.nat{c = 0 || c = 1} | {
"end_col": 41,
"end_line": 44,
"start_col": 2,
"start_line": 43
} |
FStar.Tactics.Effect.Tac | val check
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term })
: T.Tac (checker_result_t g ctxt post_hint) | [
{
"abbrev": true,
"full_module": "Pulse.Typing.Metatheory",
"short_module": "Metatheory"
},
{
"abbrev": true,
"full_module": "Pulse.Syntax.Printer",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Prover",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Tactics.V2",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Checker",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let check
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term })
: T.Tac (checker_result_t g ctxt post_hint)
= match post_hint, st.term with
| Some { ctag_hint = Some ct }, Tm_Return f ->
if ct = f.ctag
then check_core g ctxt ctxt_typing post_hint res_ppname st
else let st = { st with term = Tm_Return { f with ctag=ct }} in
check_core g ctxt ctxt_typing post_hint res_ppname st
| _ -> check_core g ctxt ctxt_typing post_hint res_ppname st | val check
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term })
: T.Tac (checker_result_t g ctxt post_hint)
let check
(g: env)
(ctxt: term)
(ctxt_typing: tot_typing g ctxt tm_vprop)
(post_hint: post_hint_opt g)
(res_ppname: ppname)
(st: st_term{Tm_Return? st.term})
: T.Tac (checker_result_t g ctxt post_hint) = | true | null | false | match post_hint, st.term with
| Some { ctag_hint = Some ct }, Tm_Return f ->
if ct = f.ctag
then check_core g ctxt ctxt_typing post_hint res_ppname st
else
let st = { st with term = Tm_Return ({ f with ctag = ct }) } in
check_core g ctxt ctxt_typing post_hint res_ppname st
| _ -> check_core g ctxt ctxt_typing post_hint res_ppname st | {
"checked_file": "Pulse.Checker.Return.fst.checked",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Checker.Pure.fsti.checked",
"Pulse.Checker.Prover.fsti.checked",
"Pulse.Checker.Base.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Checker.Return.fst"
} | [] | [
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.term",
"Pulse.Typing.tot_typing",
"Pulse.Syntax.Base.tm_vprop",
"Pulse.Typing.post_hint_opt",
"Pulse.Syntax.Base.ppname",
"Pulse.Syntax.Base.st_term",
"Prims.b2t",
"Pulse.Syntax.Base.uu___is_Tm_Return",
"Pulse.Syntax.Base.__proj__Mkst_term__item__term",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"Pulse.Typing.post_hint_t",
"Pulse.Syntax.Base.st_term'",
"Pulse.Syntax.Base.ctag",
"Pulse.Syntax.Base.universe",
"Pulse.Typing.universe_of",
"FStar.Ghost.erased",
"FStar.Reflection.Typing.tot_typing",
"Pulse.Typing.elab_env",
"FStar.Reflection.Typing.mk_abs",
"Pulse.Elaborate.Pure.elab_term",
"FStar.Reflection.V2.Data.Q_Explicit",
"FStar.Reflection.Typing.mk_arrow",
"Pulse.Syntax.Base.st_term'__Tm_Return__payload",
"Prims.op_Equality",
"Pulse.Syntax.Base.__proj__Mkst_term'__Tm_Return__payload__item__ctag",
"Pulse.Checker.Return.check_core",
"Pulse.Checker.Base.checker_result_t",
"Prims.bool",
"Pulse.Syntax.Base.Mkst_term",
"Pulse.Syntax.Base.Tm_Return",
"Pulse.Syntax.Base.Mkst_term'__Tm_Return__payload",
"Pulse.Syntax.Base.__proj__Mkst_term'__Tm_Return__payload__item__insert_eq",
"Pulse.Syntax.Base.__proj__Mkst_term'__Tm_Return__payload__item__term",
"Pulse.Syntax.Base.__proj__Mkst_term__item__range",
"Pulse.Syntax.Base.__proj__Mkst_term__item__effect_tag",
"FStar.Pervasives.Native.tuple2"
] | [] | module Pulse.Checker.Return
open Pulse.Syntax
open Pulse.Typing
open Pulse.Checker.Pure
open Pulse.Checker.Base
open Pulse.Checker.Prover
module T = FStar.Tactics.V2
module P = Pulse.Syntax.Printer
module Metatheory = Pulse.Typing.Metatheory
let check_core
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term })
: T.Tac (checker_result_t g ctxt post_hint) =
let g = push_context "check_return" st.range g in
let Tm_Return {ctag=c; insert_eq=use_eq; term=t} = st.term in
let (| t, u, ty, uty, d |) :
t:term &
u:universe &
ty:term &
universe_of g ty u &
tot_typing g t ty =
match post_hint with
| None -> check_tot_term_and_type g t
| Some post ->
let (| t, d |) = check_tot_term_with_expected_type g t post.ret_ty in
assert (g `env_extends` post.g);
let ty_typing : universe_of post.g post.ret_ty post.u =
post.ty_typing in
let ty_typing : universe_of g post.ret_ty post.u =
Metatheory.tot_typing_weakening_standard post.g post.ty_typing g in
(| t, post.u, post.ret_ty, ty_typing, d |)
in
let x = fresh g in
let px = res_ppname, x in
let (| post_opened, post_typing |) : t:term & tot_typing (push_binding g x (fst px) ty) t tm_vprop =
match post_hint with
| None ->
let (| t, ty |) = check_tot_term_with_expected_type (push_binding g x (fst px) ty) tm_emp tm_vprop in
(| t, ty |)
| Some post ->
// we already checked for the return type
let post : post_hint_t = post in
if x `Set.mem` (freevars post.post)
then fail g None
("check_return: unexpected variable clash in return post,\
please file a bug report")
else
let ty_rec = post_hint_typing g post x in
(| open_term_nv post.post px, ty_rec.post_typing |)
in
assume (open_term (close_term post_opened x) x == post_opened);
let post = close_term post_opened x in
let d = T_Return g c use_eq u ty t post x uty d post_typing in
prove_post_hint (try_frame_pre ctxt_typing (match_comp_res_with_post_hint d post_hint) res_ppname) post_hint t.range
let check
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term }) | false | false | Pulse.Checker.Return.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val check
(g:env)
(ctxt:term)
(ctxt_typing:tot_typing g ctxt tm_vprop)
(post_hint:post_hint_opt g)
(res_ppname:ppname)
(st:st_term { Tm_Return? st.term })
: T.Tac (checker_result_t g ctxt post_hint) | [] | Pulse.Checker.Return.check | {
"file_name": "lib/steel/pulse/Pulse.Checker.Return.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
g: Pulse.Typing.Env.env ->
ctxt: Pulse.Syntax.Base.term ->
ctxt_typing: Pulse.Typing.tot_typing g ctxt Pulse.Syntax.Base.tm_vprop ->
post_hint: Pulse.Typing.post_hint_opt g ->
res_ppname: Pulse.Syntax.Base.ppname ->
st: Pulse.Syntax.Base.st_term{Tm_Return? (Mkst_term?.term st)}
-> FStar.Tactics.Effect.Tac (Pulse.Checker.Base.checker_result_t g ctxt post_hint) | {
"end_col": 65,
"end_line": 80,
"start_col": 4,
"start_line": 74
} |
Prims.Tot | val va_quick_KeyExpansion128Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion128Stdcall ())) =
(va_QProc (va_code_KeyExpansion128Stdcall ()) ([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b)) | val va_quick_KeyExpansion128Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall ()))
let va_quick_KeyExpansion128Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall ())) = | false | null | false | (va_QProc (va_code_KeyExpansion128Stdcall ())
([
va_Mod_vec 4;
va_Mod_vec 3;
va_Mod_vec 2;
va_Mod_vec 1;
va_Mod_vec 0;
va_Mod_reg 10;
va_Mod_mem_heaplet 1;
va_Mod_mem
])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b)) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES128.va_code_KeyExpansion128Stdcall",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Vale.PPC64LE.QuickCode.va_Mod_mem_heaplet",
"Vale.PPC64LE.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.PPC64LE.AES128.va_wp_KeyExpansion128Stdcall",
"Vale.AES.PPC64LE.AES128.va_wpProof_KeyExpansion128Stdcall",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansion128Stdcall ())
([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10;
va_Mod_mem_heaplet 1; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) : | false | false | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_KeyExpansion128Stdcall (input_key_b output_key_expansion_b: buffer128)
: (va_quickCode unit (va_code_KeyExpansion128Stdcall ())) | [] | Vale.AES.PPC64LE.AES128.va_quick_KeyExpansion128Stdcall | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | input_key_b: Vale.PPC64LE.Memory.buffer128 -> output_key_expansion_b: Vale.PPC64LE.Memory.buffer128
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.AES.PPC64LE.AES128.va_code_KeyExpansion128Stdcall ()) | {
"end_col": 75,
"end_line": 98,
"start_col": 2,
"start_line": 95
} |
Prims.Tot | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptBlock ())) =
(va_QProc (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES128EncryptBlock input key round_keys keys_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer)) | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ()))
let va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) = | false | null | false | (va_QProc (va_code_AES128EncryptBlock ())
([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES128EncryptBlock input key round_keys keys_buffer)
(va_wpProof_AES128EncryptBlock input key round_keys keys_buffer)) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES128.va_code_AES128EncryptBlock",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Prims.Nil",
"Vale.AES.PPC64LE.AES128.va_wp_AES128EncryptBlock",
"Vale.AES.PPC64LE.AES128.va_wpProof_AES128EncryptBlock",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansion128Stdcall ())
([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10;
va_Mod_mem_heaplet 1; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion128Stdcall ())) =
(va_QProc (va_code_KeyExpansion128Stdcall ()) ([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ va_get_ok va_s0 /\
Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys == 11
/\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 ==
input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | false | false | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock ())) | [] | Vale.AES.PPC64LE.AES128.va_quick_AES128EncryptBlock | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.AES.PPC64LE.AES128.va_code_AES128EncryptBlock ()) | {
"end_col": 38,
"end_line": 149,
"start_col": 2,
"start_line": 147
} |
Prims.Tot | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input ==> va_k va_sM (()))) | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\
FStar.Seq.Base.length #quad32 round_keys == 11 /\
round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 == input /\
va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer
(va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
keys_buffer
11
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer
i
(va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10: nat64) (va_x_v0: quad32) (va_x_v2: quad32).
let va_sM = va_upd_vec 2 va_x_v2 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in
va_get_ok va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_128",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_get_vec",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Memory.buffer_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"FStar.Seq.Base.index",
"Vale.PPC64LE.Memory.nat64",
"Vale.AES.AES_BE_s.aes_encrypt_word",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansion128Stdcall ())
([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10;
va_Mod_mem_heaplet 1; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion128Stdcall ())) =
(va_QProc (va_code_KeyExpansion128Stdcall ()) ([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ va_get_ok va_s0 /\
Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys == 11
/\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 ==
input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) | false | true | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_AES128EncryptBlock
(input: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES128.va_wp_AES128EncryptBlock | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 81,
"end_line": 135,
"start_col": 2,
"start_line": 125
} |
Prims.Tot | val va_quick_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock_6way ())) | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_AES128EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32)
(in5:quad32) (in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) :
(va_quickCode unit (va_code_AES128EncryptBlock_6way ())) =
(va_QProc (va_code_AES128EncryptBlock_6way ()) ([va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4;
va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES128EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_buffer)
(va_wpProof_AES128EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_buffer)) | val va_quick_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock_6way ()))
let va_quick_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock_6way ())) = | false | null | false | (va_QProc (va_code_AES128EncryptBlock_6way ())
([
va_Mod_vec 6;
va_Mod_vec 5;
va_Mod_vec 4;
va_Mod_vec 3;
va_Mod_vec 2;
va_Mod_vec 1;
va_Mod_vec 0;
va_Mod_reg 10
])
(va_wp_AES128EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_buffer)
(va_wpProof_AES128EncryptBlock_6way in1 in2 in3 in4 in5 in6 key round_keys keys_buffer)) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.PPC64LE.AES128.va_code_AES128EncryptBlock_6way",
"Prims.Cons",
"Vale.PPC64LE.QuickCode.mod_t",
"Vale.PPC64LE.QuickCode.va_Mod_vec",
"Vale.PPC64LE.QuickCode.va_Mod_reg",
"Prims.Nil",
"Vale.AES.PPC64LE.AES128.va_wp_AES128EncryptBlock_6way",
"Vale.AES.PPC64LE.AES128.va_wpProof_AES128EncryptBlock_6way",
"Vale.PPC64LE.QuickCode.va_quickCode"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansion128Stdcall ())
([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10;
va_Mod_mem_heaplet 1; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion128Stdcall ())) =
(va_QProc (va_code_KeyExpansion128Stdcall ()) ([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ va_get_ok va_s0 /\
Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys == 11
/\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 ==
input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptBlock ())) =
(va_QProc (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES128EncryptBlock input key round_keys keys_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES128EncryptBlock_6way
val va_code_AES128EncryptBlock_6way : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock_6way : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock_6way : va_b0:va_code -> va_s0:va_state -> in1:quad32 -> in2:quad32
-> in3:quad32 -> in4:quad32 -> in5:quad32 -> in6:quad32 -> key:(seq nat32) -> round_keys:(seq
quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock_6way ()) va_s0 /\ va_get_ok va_s0
/\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys ==
11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0
== in1 /\ va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\ va_get_vec 3 va_s0 == in4
/\ va_get_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\ va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0
va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in1 /\ va_get_vec 1 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in6 /\ va_state_eq va_sM (va_update_vec 6 va_sM
(va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM
(va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0)))))))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32) (in5:quad32)
(in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == in1 /\ va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\
va_get_vec 3 va_s0 == in4 /\ va_get_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat)
. i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32)
(va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6 va_x_v6
(va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
(va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in1 /\ va_get_vec
1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in6 ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock_6way : in1:quad32 -> in2:quad32 -> in3:quad32 -> in4:quad32 ->
in5:quad32 -> in6:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock_6way in1 in2 in3 in4 in5 in6 key
round_keys keys_buffer va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock_6way ())
([va_Mod_vec 6; va_Mod_vec 5; va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32)
(in5:quad32) (in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) : | false | false | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
: (va_quickCode unit (va_code_AES128EncryptBlock_6way ())) | [] | Vale.AES.PPC64LE.AES128.va_quick_AES128EncryptBlock_6way | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
in1: Vale.PPC64LE.Memory.quad32 ->
in2: Vale.PPC64LE.Memory.quad32 ->
in3: Vale.PPC64LE.Memory.quad32 ->
in4: Vale.PPC64LE.Memory.quad32 ->
in5: Vale.PPC64LE.Memory.quad32 ->
in6: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128
-> Vale.PPC64LE.QuickCode.va_quickCode Prims.unit
(Vale.AES.PPC64LE.AES128.va_code_AES128EncryptBlock_6way ()) | {
"end_col": 92,
"end_line": 221,
"start_col": 2,
"start_line": 218
} |
Prims.Tot | val va_wp_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_AES128EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32) (in5:quad32)
(in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) (va_s0:va_state)
(va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == in1 /\ va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\
va_get_vec 3 va_s0 == in4 /\ va_get_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat)
. i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
keys_buffer i (va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10:nat64) (va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32)
(va_x_v4:quad32) (va_x_v5:quad32) (va_x_v6:quad32) . let va_sM = va_upd_vec 6 va_x_v6
(va_upd_vec 5 va_x_v5 (va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2
(va_upd_vec 1 va_x_v1 (va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0))))))) in va_get_ok
va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in1 /\ va_get_vec
1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in6 ==> va_k va_sM (()))) | val va_wp_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\
FStar.Seq.Base.length #quad32 round_keys == 11 /\
round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 == in1 /\
va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\ va_get_vec 3 va_s0 == in4 /\
va_get_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\
va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer
(va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
keys_buffer
11
(va_get_mem_layout va_s0)
Secret /\
(forall (i: nat).
i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer
i
(va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i) /\
(forall (va_x_r10: nat64)
(va_x_v0: quad32)
(va_x_v1: quad32)
(va_x_v2: quad32)
(va_x_v3: quad32)
(va_x_v4: quad32)
(va_x_v5: quad32)
(va_x_v6: quad32).
let va_sM =
va_upd_vec 6
va_x_v6
(va_upd_vec 5
va_x_v5
(va_upd_vec 4
va_x_v4
(va_upd_vec 3
va_x_v3
(va_upd_vec 2
va_x_v2
(va_upd_vec 1
va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)))))))
in
va_get_ok va_sM /\ va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in1 /\
va_get_vec 1 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in2 /\
va_get_vec 2 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in3 /\
va_get_vec 3 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in4 /\
va_get_vec 4 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in5 /\
va_get_vec 5 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in6 ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.quad32",
"FStar.Seq.Base.seq",
"Vale.PPC64LE.Memory.nat32",
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.AES.AES_BE_s.is_aes_key_word",
"Vale.AES.AES_common_s.AES_128",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.Def.Types_s.quad32",
"Vale.PPC64LE.Decls.va_get_vec",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Memory.buffer_addr",
"Vale.PPC64LE.Memory.vuint128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"FStar.Seq.Base.index",
"Vale.PPC64LE.Memory.nat64",
"Vale.AES.AES_BE_s.aes_encrypt_word",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (())))
val va_wpProof_KeyExpansion128Stdcall : input_key_b:buffer128 -> output_key_expansion_b:buffer128
-> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b
va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansion128Stdcall ())
([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2; va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10;
va_Mod_mem_heaplet 1; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) :
(va_quickCode unit (va_code_KeyExpansion128Stdcall ())) =
(va_QProc (va_code_KeyExpansion128Stdcall ()) ([va_Mod_vec 4; va_Mod_vec 3; va_Mod_vec 2;
va_Mod_vec 1; va_Mod_vec 0; va_Mod_reg 10; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansion128Stdcall input_key_b output_key_expansion_b)
(va_wpProof_KeyExpansion128Stdcall input_key_b output_key_expansion_b))
//--
//-- AES128EncryptBlock
val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock : va_b0:va_code -> va_s0:va_state -> input:quad32 -> key:(seq
nat32) -> round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock ()) va_s0 /\ va_get_ok va_s0 /\
Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys == 11
/\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0 ==
input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128
keys_buffer (va_get_mem_heaplet 0 va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128
(va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0) keys_buffer 11 (va_get_mem_layout va_s0)
Secret /\ (forall (i:nat) . i < 11 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read keys_buffer i (va_get_mem_heaplet 0 va_s0)) ==
FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input /\ va_state_eq va_sM
(va_update_vec 2 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length
#quad32 round_keys == 11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key
/\ va_get_vec 0 va_s0 == input /\ va_get_reg 4 va_s0 == Vale.PPC64LE.Memory.buffer_addr
#Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0) /\
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i) /\ (forall
(va_x_r10:nat64) (va_x_v0:quad32) (va_x_v2:quad32) . let va_sM = va_upd_vec 2 va_x_v2
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 va_s0)) in va_get_ok va_sM /\ va_get_vec 0 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key input ==> va_k va_sM (())))
val va_wpProof_AES128EncryptBlock : input:quad32 -> key:(seq nat32) -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptBlock input key round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2;
va_Mod_vec 0; va_Mod_reg 10]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptBlock (input:quad32) (key:(seq nat32)) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptBlock ())) =
(va_QProc (va_code_AES128EncryptBlock ()) ([va_Mod_vec 2; va_Mod_vec 0; va_Mod_reg 10])
(va_wp_AES128EncryptBlock input key round_keys keys_buffer) (va_wpProof_AES128EncryptBlock
input key round_keys keys_buffer))
//--
//-- AES128EncryptBlock_6way
val va_code_AES128EncryptBlock_6way : va_dummy:unit -> Tot va_code
val va_codegen_success_AES128EncryptBlock_6way : va_dummy:unit -> Tot va_pbool
val va_lemma_AES128EncryptBlock_6way : va_b0:va_code -> va_s0:va_state -> in1:quad32 -> in2:quad32
-> in3:quad32 -> in4:quad32 -> in5:quad32 -> in6:quad32 -> key:(seq nat32) -> round_keys:(seq
quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptBlock_6way ()) va_s0 /\ va_get_ok va_s0
/\ Vale.AES.AES_BE_s.is_aes_key_word AES_128 key /\ FStar.Seq.Base.length #quad32 round_keys ==
11 /\ round_keys == Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key /\ va_get_vec 0 va_s0
== in1 /\ va_get_vec 1 va_s0 == in2 /\ va_get_vec 2 va_s0 == in3 /\ va_get_vec 3 va_s0 == in4
/\ va_get_vec 4 va_s0 == in5 /\ va_get_vec 5 va_s0 == in6 /\ va_get_reg 4 va_s0 ==
Vale.PPC64LE.Memory.buffer_addr #Vale.PPC64LE.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0
va_s0) /\ Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ (forall (i:nat) . i < 11 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read keys_buffer i
(va_get_mem_heaplet 0 va_s0)) == FStar.Seq.Base.index #quad32 round_keys i)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_vec 0 va_sM == Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in1 /\ va_get_vec 1 va_sM
== Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in2 /\ va_get_vec 2 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in3 /\ va_get_vec 3 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in4 /\ va_get_vec 4 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in5 /\ va_get_vec 5 va_sM ==
Vale.AES.AES_BE_s.aes_encrypt_word AES_128 key in6 /\ va_state_eq va_sM (va_update_vec 6 va_sM
(va_update_vec 5 va_sM (va_update_vec 4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM
(va_update_vec 1 va_sM (va_update_vec 0 va_sM (va_update_reg 10 va_sM (va_update_ok va_sM
va_s0)))))))))))
[@ va_qattr]
let va_wp_AES128EncryptBlock_6way (in1:quad32) (in2:quad32) (in3:quad32) (in4:quad32) (in5:quad32)
(in6:quad32) (key:(seq nat32)) (round_keys:(seq quad32)) (keys_buffer:buffer128) (va_s0:va_state) | false | true | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_AES128EncryptBlock_6way
(in1 in2 in3 in4 in5 in6: quad32)
(key: (seq nat32))
(round_keys: (seq quad32))
(keys_buffer: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES128.va_wp_AES128EncryptBlock_6way | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
in1: Vale.PPC64LE.Memory.quad32 ->
in2: Vale.PPC64LE.Memory.quad32 ->
in3: Vale.PPC64LE.Memory.quad32 ->
in4: Vale.PPC64LE.Memory.quad32 ->
in5: Vale.PPC64LE.Memory.quad32 ->
in6: Vale.PPC64LE.Memory.quad32 ->
key: FStar.Seq.Base.seq Vale.PPC64LE.Memory.nat32 ->
round_keys: FStar.Seq.Base.seq Vale.PPC64LE.Memory.quad32 ->
keys_buffer: Vale.PPC64LE.Memory.buffer128 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 76,
"end_line": 203,
"start_col": 2,
"start_line": 185
} |
Prims.Tot | val va_wp_KeyExpansion128Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers_BE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_BE_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_r10:nat64)
(va_x_v0:quad32) (va_x_v1:quad32) (va_x_v2:quad32) (va_x_v3:quad32) (va_x_v4:quad32) . let
va_sM = va_upd_vec 4 va_x_v4 (va_upd_vec 3 va_x_v3 (va_upd_vec 2 va_x_v2 (va_upd_vec 1 va_x_v1
(va_upd_vec 0 va_x_v0 (va_upd_reg 10 va_x_r10 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))))) in va_get_ok va_sM /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0
va_sM) (va_get_reg 4 va_sM) input_key_b 1 (va_get_mem_layout va_sM) Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM)
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq
Vale.Def.Types_s.nat32)) = Vale.AES.AES_helpers_BE.be_quad32_to_seq
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read input_key_b 0
(va_get_mem_heaplet 0 va_s0))) in Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1 va_sM) /\ (forall j .
{:pattern(reverse_bytes_quad32 (buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1
va_sM)))}0 <= j /\ j <= 10 ==> Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_BE_s.key_to_round_keys_word AES_128
key) j)) ==> va_k va_sM (()))) | val va_wp_KeyExpansion128Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_KeyExpansion128Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_get_ok va_s0 /\
(let key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
input_key_b
0
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg 4 va_s0)
input_key_b
1
(va_get_mem_layout va_s0)
Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg 3 va_s0)
output_key_expansion_b
11
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap)
(va_x_heap1: vale_heap)
(va_x_r10: nat64)
(va_x_v0: quad32)
(va_x_v1: quad32)
(va_x_v2: quad32)
(va_x_v3: quad32)
(va_x_v4: quad32).
let va_sM =
va_upd_vec 4
va_x_v4
(va_upd_vec 3
va_x_v3
(va_upd_vec 2
va_x_v2
(va_upd_vec 1
va_x_v1
(va_upd_vec 0
va_x_v0
(va_upd_reg 10
va_x_r10
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem va_x_mem va_s0)))))))
in
va_get_ok va_sM /\
(let key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
input_key_b
0
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM)
(va_get_reg 4 va_sM)
input_key_b
1
(va_get_mem_layout va_sM)
Secret /\
Vale.PPC64LE.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM)
(va_get_reg 3 va_sM)
output_key_expansion_b
11
(va_get_mem_layout va_sM)
Secret) /\
(let key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read
input_key_b
0
(va_get_mem_heaplet 0 va_s0)))
in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\
(forall j.
{:pattern
(reverse_bytes_quad32 (buffer128_read output_key_expansion_b
j
(va_get_mem_heaplet 1 va_sM)))}
0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j
(va_get_mem_heaplet 1 va_sM)) ==
FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key)
j)) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.PPC64LE.AES128.fsti.checked",
"dependencies": [
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.PPC64LE.InsVector.fsti.checked",
"Vale.PPC64LE.InsMem.fsti.checked",
"Vale.PPC64LE.InsBasic.fsti.checked",
"Vale.PPC64LE.Decls.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_helpers_BE.fsti.checked",
"Vale.AES.AES_BE_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.PPC64LE.AES128.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Memory.buffer128",
"Vale.PPC64LE.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Decls.va_get_ok",
"Vale.PPC64LE.Decls.validSrcAddrs128",
"Vale.PPC64LE.Decls.va_get_mem_heaplet",
"Vale.PPC64LE.Decls.va_get_reg",
"Vale.PPC64LE.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.PPC64LE.Decls.validDstAddrs128",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat32",
"Vale.AES.AES_helpers_BE.be_quad32_to_seq",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.PPC64LE.Decls.buffer128_read",
"Prims.l_Forall",
"Vale.PPC64LE.InsBasic.vale_heap",
"Vale.PPC64LE.Memory.nat64",
"Vale.PPC64LE.Memory.quad32",
"Prims.l_imp",
"Vale.PPC64LE.Decls.modifies_buffer128",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_BE_s.key_to_round_keys_word",
"Vale.AES.AES_common_s.AES_128",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"FStar.Seq.Base.index",
"Vale.PPC64LE.Machine_s.state",
"Vale.PPC64LE.Decls.va_upd_vec",
"Vale.PPC64LE.Decls.va_upd_reg",
"Vale.PPC64LE.Decls.va_upd_mem_heaplet",
"Vale.PPC64LE.Decls.va_upd_mem"
] | [] | module Vale.AES.PPC64LE.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_BE_s
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open Vale.PPC64LE.InsBasic
open Vale.PPC64LE.InsMem
open Vale.PPC64LE.InsVector
open Vale.PPC64LE.QuickCode
open Vale.PPC64LE.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers_BE
#reset-options "--z3rlimit 20"
//-- KeyExpansion128Stdcall
val va_code_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_code
val va_codegen_success_KeyExpansion128Stdcall : va_dummy:unit -> Tot va_pbool
val va_lemma_KeyExpansion128Stdcall : va_b0:va_code -> va_s0:va_state -> input_key_b:buffer128 ->
output_key_expansion_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansion128Stdcall ()) va_s0 /\ va_get_ok va_s0 /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg 4 va_s0)
input_key_b 1 (va_get_mem_layout va_s0) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_s0) (va_get_reg 3 va_s0) output_key_expansion_b 11 (va_get_mem_layout
va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) (va_get_reg 4 va_sM)
input_key_b 1 (va_get_mem_layout va_sM) Secret /\ Vale.PPC64LE.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg 3 va_sM) output_key_expansion_b 11 (va_get_mem_layout
va_sM) Secret) /\ (let (key:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) =
Vale.AES.AES_helpers_BE.be_quad32_to_seq (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.PPC64LE.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet 0 va_s0))) in
Vale.PPC64LE.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(reverse_bytes_quad32 (buffer128_read
output_key_expansion_b j (va_get_mem_heaplet 1 va_sM)))}0 <= j /\ j <= 10 ==>
Vale.Def.Types_s.reverse_bytes_quad32 (Vale.PPC64LE.Decls.buffer128_read output_key_expansion_b
j (va_get_mem_heaplet 1 va_sM)) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32
(Vale.AES.AES_BE_s.key_to_round_keys_word AES_128 key) j)) /\ va_state_eq va_sM (va_update_vec
4 va_sM (va_update_vec 3 va_sM (va_update_vec 2 va_sM (va_update_vec 1 va_sM (va_update_vec 0
va_sM (va_update_reg 10 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))
[@ va_qattr]
let va_wp_KeyExpansion128Stdcall (input_key_b:buffer128) (output_key_expansion_b:buffer128) | false | true | Vale.AES.PPC64LE.AES128.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_KeyExpansion128Stdcall
(input_key_b output_key_expansion_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.PPC64LE.AES128.va_wp_KeyExpansion128Stdcall | {
"file_name": "obj/Vale.AES.PPC64LE.AES128.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
input_key_b: Vale.PPC64LE.Memory.buffer128 ->
output_key_expansion_b: Vale.PPC64LE.Memory.buffer128 ->
va_s0: Vale.PPC64LE.Decls.va_state ->
va_k: (_: Vale.PPC64LE.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 34,
"end_line": 82,
"start_col": 2,
"start_line": 57
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let stable_property (#a:Type) (p:Preorder.preorder a)
= fact:property a { Preorder.stable fact p } | let stable_property (#a: Type) (p: Preorder.preorder a) = | false | null | false | fact: property a {Preorder.stable fact p} | {
"checked_file": "Steel.GhostMonotonicReference.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.GhostMonotonicReference.fsti"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.GhostMonotonicReference.property",
"FStar.Preorder.stable"
] | [] | (*
Copyright 2020 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 Steel.GhostMonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
/// A library for Steel references that are monotonic with respect to a user-specified preorder.
/// This library builds on top of Steel.HigherReference, and is specialized to values at universe 1.
/// An abstract datatype for monotonic references
[@@erasable]
val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
/// The standard points to separation logic predicate
val pts_to_sl (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__]
unfold
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: vprop
= to_vprop (pts_to_sl r f v)
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
val alloc (#opened: _) (#a:Type) (p:Preorder.preorder a) (v:a)
: SteelGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
val write (#opened: _) (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: SteelGhost unit opened (pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires fun _ -> p v x /\ True)
(ensures fun _ _ _ -> True)
/// A wrapper around a predicate that depends on a value of type [a]
let property (a:Type)
= a -> prop
/// A wrapper around a property [fact] that has been witnessed to be true and stable
/// with respect to preorder [p]
val witnessed (#a:Type u#0) (#p:Preorder.preorder a) (r:ref a p) (fact:property a)
: Type0
/// The type of properties depending on values of type [a], and that
/// are stable with respect to the preorder [p] | false | false | Steel.GhostMonotonicReference.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val stable_property : p: FStar.Preorder.preorder a -> Type | [] | Steel.GhostMonotonicReference.stable_property | {
"file_name": "lib/steel/Steel.GhostMonotonicReference.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: FStar.Preorder.preorder a -> Type | {
"end_col": 46,
"end_line": 81,
"start_col": 4,
"start_line": 81
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let property (a:Type)
= a -> prop | let property (a: Type) = | false | null | false | a -> prop | {
"checked_file": "Steel.GhostMonotonicReference.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.GhostMonotonicReference.fsti"
} | [
"total"
] | [
"Prims.prop"
] | [] | (*
Copyright 2020 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 Steel.GhostMonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
/// A library for Steel references that are monotonic with respect to a user-specified preorder.
/// This library builds on top of Steel.HigherReference, and is specialized to values at universe 1.
/// An abstract datatype for monotonic references
[@@erasable]
val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
/// The standard points to separation logic predicate
val pts_to_sl (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__]
unfold
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: vprop
= to_vprop (pts_to_sl r f v)
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
val alloc (#opened: _) (#a:Type) (p:Preorder.preorder a) (v:a)
: SteelGhostT (ref a p) opened emp (fun r -> pts_to r full_perm v)
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
val write (#opened: _) (#a:Type) (#p:Preorder.preorder a) (#v:a)
(r:ref a p) (x:a)
: SteelGhost unit opened (pts_to r full_perm v)
(fun v -> pts_to r full_perm x)
(requires fun _ -> p v x /\ True)
(ensures fun _ _ _ -> True)
/// A wrapper around a predicate that depends on a value of type [a] | false | true | Steel.GhostMonotonicReference.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val property : a: Type -> Type | [] | Steel.GhostMonotonicReference.property | {
"file_name": "lib/steel/Steel.GhostMonotonicReference.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> Type | {
"end_col": 13,
"end_line": 71,
"start_col": 4,
"start_line": 71
} |
|
Prims.Tot | val pts_to (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a) : vprop | [
{
"abbrev": true,
"full_module": "FStar.Universe",
"short_module": "U"
},
{
"abbrev": true,
"full_module": "Steel.GhostMonotonicHigherReference",
"short_module": "MHR"
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "Preorder"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: vprop
= to_vprop (pts_to_sl r f v) | val pts_to (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a) : vprop
let pts_to (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a) : vprop = | false | null | false | to_vprop (pts_to_sl r f v) | {
"checked_file": "Steel.GhostMonotonicReference.fsti.checked",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.GhostMonotonicReference.fsti"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"Steel.GhostMonotonicReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.GhostMonotonicReference.pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | (*
Copyright 2020 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 Steel.GhostMonotonicReference
open FStar.PCM
open FStar.Ghost
open Steel.FractionalPermission
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Preorder = FStar.Preorder
/// A library for Steel references that are monotonic with respect to a user-specified preorder.
/// This library builds on top of Steel.HigherReference, and is specialized to values at universe 1.
/// An abstract datatype for monotonic references
[@@erasable]
val ref (a:Type u#0) (p:Preorder.preorder a)
: Type u#0
/// The standard points to separation logic predicate
val pts_to_sl (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a)
: slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__]
unfold
let pts_to (#a:Type)
(#p:Preorder.preorder a)
(r:ref a p)
(f:perm)
(v:a) | false | false | Steel.GhostMonotonicReference.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pts_to (#a: Type) (#p: Preorder.preorder a) (r: ref a p) (f: perm) (v: a) : vprop | [] | Steel.GhostMonotonicReference.pts_to | {
"file_name": "lib/steel/Steel.GhostMonotonicReference.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.GhostMonotonicReference.ref a p -> f: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | {
"end_col": 31,
"end_line": 54,
"start_col": 5,
"start_line": 54
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repeati = Lib.LoopCombinators.repeati | let repeati = | false | null | false | Lib.LoopCombinators.repeati | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.LoopCombinators.repeati",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64 | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repeati : n: Prims.nat -> f: (i: Prims.nat{i < n} -> _: _ -> _) -> acc0: _ -> _ | [] | Vale.Poly1305.Equiv.repeati | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Prims.nat -> f: (i: Prims.nat{i < n} -> _: _ -> _) -> acc0: _ -> _ | {
"end_col": 48,
"end_line": 17,
"start_col": 21,
"start_line": 17
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let iand #n = Vale.Def.Types_s.iand #n | let iand #n = | false | null | false | Vale.Def.Types_s.iand #n | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Def.Types_s.iand",
"Vale.Def.Words_s.natN"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128 | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val iand : a: Vale.Def.Words_s.natN n -> b: Vale.Def.Words_s.natN n -> Vale.Def.Words_s.natN n | [] | Vale.Poly1305.Equiv.iand | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Def.Words_s.natN n -> b: Vale.Def.Words_s.natN n -> Vale.Def.Words_s.natN n | {
"end_col": 45,
"end_line": 11,
"start_col": 21,
"start_line": 11
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repeat_blocks_f = Lib.Sequence.repeat_blocks_f | let repeat_blocks_f = | false | null | false | Lib.Sequence.repeat_blocks_f | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.Sequence.repeat_blocks_f",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_GreaterThan",
"Lib.Sequence.seq",
"Lib.Sequence.lseq",
"Prims.eq2",
"Prims.int",
"Prims.op_Division",
"Lib.Sequence.length",
"Prims.op_LessThan"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repeat_blocks_f : bs: (n: Prims.nat{n <= Prims.pow2 32 - 1}){bs > 0} ->
inp: Lib.Sequence.seq _ ->
f: (_: Lib.Sequence.lseq _ bs -> _: _ -> _) ->
nb: Prims.nat{nb == Lib.Sequence.length inp / bs} ->
i: Prims.nat{i < nb} ->
acc: _
-> _ | [] | Vale.Poly1305.Equiv.repeat_blocks_f | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
bs: (n: Prims.nat{n <= Prims.pow2 32 - 1}){bs > 0} ->
inp: Lib.Sequence.seq _ ->
f: (_: Lib.Sequence.lseq _ bs -> _: _ -> _) ->
nb: Prims.nat{nb == Lib.Sequence.length inp / bs} ->
i: Prims.nat{i < nb} ->
acc: _
-> _ | {
"end_col": 57,
"end_line": 19,
"start_col": 29,
"start_line": 19
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul = S.fmul | let fmul = | false | null | false | S.fmul | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Spec.Poly1305.fmul"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul : x: Spec.Poly1305.felem -> y: Spec.Poly1305.felem -> Spec.Poly1305.felem | [] | Vale.Poly1305.Equiv.fmul | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.Poly1305.felem -> y: Spec.Poly1305.felem -> Spec.Poly1305.felem | {
"end_col": 24,
"end_line": 26,
"start_col": 18,
"start_line": 26
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let modp = V.modp | let modp = | false | null | false | V.modp | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Vale.Poly1305.Spec_s.modp"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val modp : x: Prims.int -> Prims.int | [] | Vale.Poly1305.Equiv.modp | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.int -> Prims.int | {
"end_col": 24,
"end_line": 28,
"start_col": 18,
"start_line": 28
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint_v #t #l = Lib.IntTypes.uint_v #t #l | let uint_v #t #l = | false | null | false | Lib.IntTypes.uint_v #t #l | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.inttype",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Lib.IntTypes.secrecy_level",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.int_t",
"Prims.int",
"Lib.IntTypes.range"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint_v : u15: Lib.IntTypes.int_t t l -> x: Prims.int{Lib.IntTypes.range x t} | [] | Vale.Poly1305.Equiv.uint_v | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u15: Lib.IntTypes.int_t t l -> x: Prims.int{Lib.IntTypes.range x t} | {
"end_col": 51,
"end_line": 13,
"start_col": 26,
"start_line": 13
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let u64 = Lib.IntTypes.u64 | let u64 = | false | null | false | Lib.IntTypes.u64 | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.u64"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val u64 : n: Lib.IntTypes.range_t Lib.IntTypes.U64 -> u15: Lib.IntTypes.uint64{Lib.IntTypes.v u15 == n} | [] | Vale.Poly1305.Equiv.u64 | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | n: Lib.IntTypes.range_t Lib.IntTypes.U64 -> u15: Lib.IntTypes.uint64{Lib.IntTypes.v u15 == n} | {
"end_col": 33,
"end_line": 15,
"start_col": 17,
"start_line": 15
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd = S.fadd | let fadd = | false | null | false | S.fadd | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Spec.Poly1305.fadd"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd : x: Spec.Poly1305.felem -> y: Spec.Poly1305.felem -> Spec.Poly1305.felem | [] | Vale.Poly1305.Equiv.fadd | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.Poly1305.felem -> y: Spec.Poly1305.felem -> Spec.Poly1305.felem | {
"end_col": 24,
"end_line": 25,
"start_col": 18,
"start_line": 25
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let to_felem = S.to_felem | let to_felem = | false | null | false | S.to_felem | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Spec.Poly1305.to_felem"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val to_felem : x: Prims.nat{x < Spec.Poly1305.prime} -> Spec.Poly1305.felem | [] | Vale.Poly1305.Equiv.to_felem | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.nat{x < Spec.Poly1305.prime} -> Spec.Poly1305.felem | {
"end_col": 32,
"end_line": 27,
"start_col": 22,
"start_line": 27
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prime = S.prime | let prime = | false | null | false | S.prime | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Spec.Poly1305.prime"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val prime : Prims.pos | [] | Vale.Poly1305.Equiv.prime | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.pos | {
"end_col": 26,
"end_line": 23,
"start_col": 19,
"start_line": 23
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lbytes = Lib.ByteSequence.lbytes | let lbytes = | false | null | false | Lib.ByteSequence.lbytes | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lbytes : len: Lib.IntTypes.size_nat -> Type0 | [] | Vale.Poly1305.Equiv.lbytes | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_nat -> Type0 | {
"end_col": 43,
"end_line": 21,
"start_col": 20,
"start_line": 21
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l | let uint_from_bytes_le #t #l = | false | null | false | Lib.ByteSequence.uint_from_bytes_le #t #l | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.inttype",
"Prims.l_and",
"Prims.b2t",
"Lib.IntTypes.unsigned",
"Prims.l_not",
"Lib.IntTypes.uu___is_U1",
"Lib.IntTypes.secrecy_level",
"Lib.ByteSequence.uint_from_bytes_le",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.numbytes"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint_from_bytes_le : b: Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 l) (Lib.IntTypes.numbytes t)
-> Lib.IntTypes.int_t t l | [] | Vale.Poly1305.Equiv.uint_from_bytes_le | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.Sequence.lseq (Lib.IntTypes.int_t Lib.IntTypes.U8 l) (Lib.IntTypes.numbytes t)
-> Lib.IntTypes.int_t t l | {
"end_col": 79,
"end_line": 22,
"start_col": 38,
"start_line": 22
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let nat64 = Vale.Def.Words_s.nat64 | let nat64 = | false | null | false | Vale.Def.Words_s.nat64 | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Vale.Def.Words_s.nat64"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want. | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nat64 : Type0 | [] | Vale.Poly1305.Equiv.nat64 | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 41,
"end_line": 10,
"start_col": 19,
"start_line": 10
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pow2_128 = Vale.Def.Words_s.pow2_128 | let pow2_128 = | false | null | false | Vale.Def.Words_s.pow2_128 | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Vale.Def.Words_s.pow2_128"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want. | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pow2_128 : Prims.int | [] | Vale.Poly1305.Equiv.pow2_128 | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 47,
"end_line": 9,
"start_col": 22,
"start_line": 9
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let felem = S.felem | let felem = | false | null | false | S.felem | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Spec.Poly1305.felem"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val felem : Type0 | [] | Vale.Poly1305.Equiv.felem | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 26,
"end_line": 24,
"start_col": 19,
"start_line": 24
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sub #a #len = Lib.Sequence.sub #a #len | let sub #a #len = | false | null | false | Lib.Sequence.sub #a #len | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Lib.Sequence.sub",
"Lib.Sequence.lseq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Addition",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sub : s1: Lib.Sequence.lseq a len ->
start: n: Prims.nat{n <= Prims.pow2 32 - 1} ->
n: (n: Prims.nat{n <= Prims.pow2 32 - 1}){start + n <= len}
-> s2:
Lib.Sequence.lseq a n
{ Lib.Sequence.to_seq s2 == FStar.Seq.Base.slice (Lib.Sequence.to_seq s1) start (start + n) /\
(forall (k: Prims.nat{k < n}). {:pattern Lib.Sequence.index s2 k}
Lib.Sequence.index s2 k == Lib.Sequence.index s1 (start + k)) } | [] | Vale.Poly1305.Equiv.sub | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s1: Lib.Sequence.lseq a len ->
start: n: Prims.nat{n <= Prims.pow2 32 - 1} ->
n: (n: Prims.nat{n <= Prims.pow2 32 - 1}){start + n <= len}
-> s2:
Lib.Sequence.lseq a n
{ Lib.Sequence.to_seq s2 == FStar.Seq.Base.slice (Lib.Sequence.to_seq s1) start (start + n) /\
(forall (k: Prims.nat{k < n}). {:pattern Lib.Sequence.index s2 k}
Lib.Sequence.index s2 k == Lib.Sequence.index s1 (start + k)) } | {
"end_col": 49,
"end_line": 20,
"start_col": 25,
"start_line": 20
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let logand #t #l = Lib.IntTypes.logand #t #l | let logand #t #l = | false | null | false | Lib.IntTypes.logand #t #l | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.inttype",
"Lib.IntTypes.secrecy_level",
"Lib.IntTypes.logand",
"Lib.IntTypes.int_t"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8 | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val logand : _: Lib.IntTypes.int_t t l -> _: Lib.IntTypes.int_t t l -> Lib.IntTypes.int_t t l | [] | Vale.Poly1305.Equiv.logand | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Lib.IntTypes.int_t t l -> _: Lib.IntTypes.int_t t l -> Lib.IntTypes.int_t t l | {
"end_col": 51,
"end_line": 16,
"start_col": 26,
"start_line": 16
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let size_nat = Lib.IntTypes.size_nat | let size_nat = | false | null | false | Lib.IntTypes.size_nat | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64 | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val size_nat : Type0 | [] | Vale.Poly1305.Equiv.size_nat | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 43,
"end_line": 12,
"start_col": 22,
"start_line": 12
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let uint8 = Lib.IntTypes.uint8 | let uint8 = | false | null | false | Lib.IntTypes.uint8 | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.IntTypes.uint8"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uint8 : Type0 | [] | Vale.Poly1305.Equiv.uint8 | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 37,
"end_line": 14,
"start_col": 19,
"start_line": 14
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repeat_blocks = Lib.Sequence.repeat_blocks | let repeat_blocks = | false | null | false | Lib.Sequence.repeat_blocks | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Lib.Sequence.repeat_blocks",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.Sequence.seq",
"Lib.Sequence.lseq",
"Prims.nat",
"Prims.op_LessThan"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repeat_blocks : blocksize: n: Prims.pos{n <= Prims.pow2 32 - 1} ->
inp: Lib.Sequence.seq _ ->
f: (_: Lib.Sequence.lseq _ blocksize -> _: _ -> _) ->
l: (len: Prims.nat{len < blocksize} -> s: Lib.Sequence.lseq _ len -> _: _ -> _) ->
init: _
-> _ | [] | Vale.Poly1305.Equiv.repeat_blocks | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
blocksize: n: Prims.pos{n <= Prims.pow2 32 - 1} ->
inp: Lib.Sequence.seq _ ->
f: (_: Lib.Sequence.lseq _ blocksize -> _: _ -> _) ->
l: (len: Prims.nat{len < blocksize} -> s: Lib.Sequence.lseq _ len -> _: _ -> _) ->
init: _
-> _ | {
"end_col": 53,
"end_line": 18,
"start_col": 27,
"start_line": 18
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mod2_128 = V.mod2_128 | let mod2_128 = | false | null | false | V.mod2_128 | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"total"
] | [
"Vale.Poly1305.Spec_s.mod2_128"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul
unfold let to_felem = S.to_felem | false | true | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mod2_128 : x: Prims.int -> Prims.int | [] | Vale.Poly1305.Equiv.mod2_128 | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.int -> Prims.int | {
"end_col": 32,
"end_line": 29,
"start_col": 22,
"start_line": 29
} |
|
FStar.Pervasives.Lemma | val lemma_poly1305_equiv_r (k: key)
: Lemma
(ensures
(let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_poly1305_equiv_r (k:key) : Lemma
(ensures (
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes
))
=
let key_bytes:S.block = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let mask = 0x0ffffffc0ffffffc0ffffffc0fffffff in
let rv = iand key_r mask in
let lo = uint_from_bytes_le (sub key_bytes 0 8) in
let hi = uint_from_bytes_le (sub key_bytes 8 8) in
let mask0 = u64 0x0ffffffc0fffffff in
let mask1 = u64 0x0ffffffc0ffffffc in
let mlo = logand lo mask0 in
let mhi = logand hi mask1 in
assert_norm (pow2 128 < prime);
let rs:felem = to_felem (uint_v mhi * pow2 64 + uint_v mlo) in
assert_norm (rs == S.poly1305_encode_r key_bytes);
let v_mask0:nat64 = 0x0ffffffc0fffffff in
let v_mask1:nat64 = 0x0ffffffc0ffffffc in
let v_lo:nat64 = uint_v lo in
let v_hi:nat64 = uint_v hi in
let lowerUpper128 = Vale.Poly1305.Math.lowerUpper128 in
let v_lo_hi:nat128 = lowerUpper128 v_lo v_hi in
let v_mask_0_1:nat128 = lowerUpper128 v_mask0 v_mask1 in
let z0 = iand v_lo v_mask0 in
let z1 = iand v_hi v_mask1 in
let z = lowerUpper128 z0 z1 in
let and64 = UInt.logand #64 in
calc (==) {
rv;
== {}
iand key_r mask;
== {Hacl.Impl.Poly1305.Lemmas.uint_from_bytes_le_lemma key_bytes}
iand (pow2 64 * v_hi + v_lo) mask;
== {Vale.Poly1305.Math.lowerUpper128_reveal ()}
iand v_lo_hi v_mask_0_1;
== {Vale.Poly1305.Math.lemma_lowerUpper128_and v_lo_hi v_lo v_hi v_mask_0_1 v_mask0 v_mask1 z z0 z1}
z;
== {Vale.Poly1305.Math.lowerUpper128_reveal ()}
z1 * pow2 64 + z0;
== {Vale.Arch.TypesNative.reveal_iand_all 64}
and64 v_hi v_mask1 * pow2 64 + and64 v_lo v_mask0;
== {Lib.IntTypes.logand_spec hi mask1; Lib.IntTypes.logand_spec lo mask0}
uint_v mhi * pow2 64 + uint_v mlo;
== {}
rs;
} | val lemma_poly1305_equiv_r (k: key)
: Lemma
(ensures
(let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes))
let lemma_poly1305_equiv_r (k: key)
: Lemma
(ensures
(let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes)) = | false | null | true | let key_bytes:S.block = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let mask = 0x0ffffffc0ffffffc0ffffffc0fffffff in
let rv = iand key_r mask in
let lo = uint_from_bytes_le (sub key_bytes 0 8) in
let hi = uint_from_bytes_le (sub key_bytes 8 8) in
let mask0 = u64 0x0ffffffc0fffffff in
let mask1 = u64 0x0ffffffc0ffffffc in
let mlo = logand lo mask0 in
let mhi = logand hi mask1 in
assert_norm (pow2 128 < prime);
let rs:felem = to_felem (uint_v mhi * pow2 64 + uint_v mlo) in
assert_norm (rs == S.poly1305_encode_r key_bytes);
let v_mask0:nat64 = 0x0ffffffc0fffffff in
let v_mask1:nat64 = 0x0ffffffc0ffffffc in
let v_lo:nat64 = uint_v lo in
let v_hi:nat64 = uint_v hi in
let lowerUpper128 = Vale.Poly1305.Math.lowerUpper128 in
let v_lo_hi:nat128 = lowerUpper128 v_lo v_hi in
let v_mask_0_1:nat128 = lowerUpper128 v_mask0 v_mask1 in
let z0 = iand v_lo v_mask0 in
let z1 = iand v_hi v_mask1 in
let z = lowerUpper128 z0 z1 in
let and64 = UInt.logand #64 in
calc ( == ) {
rv;
( == ) { () }
iand key_r mask;
( == ) { Hacl.Impl.Poly1305.Lemmas.uint_from_bytes_le_lemma key_bytes }
iand (pow2 64 * v_hi + v_lo) mask;
( == ) { Vale.Poly1305.Math.lowerUpper128_reveal () }
iand v_lo_hi v_mask_0_1;
( == ) { Vale.Poly1305.Math.lemma_lowerUpper128_and v_lo_hi
v_lo
v_hi
v_mask_0_1
v_mask0
v_mask1
z
z0
z1 }
z;
( == ) { Vale.Poly1305.Math.lowerUpper128_reveal () }
z1 * pow2 64 + z0;
( == ) { Vale.Arch.TypesNative.reveal_iand_all 64 }
and64 v_hi v_mask1 * pow2 64 + and64 v_lo v_mask0;
( == ) { (Lib.IntTypes.logand_spec hi mask1;
Lib.IntTypes.logand_spec lo mask0) }
uint_v mhi * pow2 64 + uint_v mlo;
( == ) { () }
rs;
} | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"lemma"
] | [
"Vale.Poly1305.Equiv.key",
"FStar.Calc.calc_finish",
"Vale.Def.Words_s.natN",
"Vale.Def.Words_s.pow2_128",
"Prims.eq2",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Vale.Poly1305.Equiv.uint_v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Vale.Poly1305.Equiv.iand",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Hacl.Impl.Poly1305.Lemmas.uint_from_bytes_le_lemma",
"Vale.Poly1305.Math.lowerUpper128_reveal",
"Vale.Poly1305.Math.lemma_lowerUpper128_and",
"Vale.Arch.TypesNative.reveal_iand_all",
"Lib.IntTypes.logand_spec",
"FStar.UInt.uint_t",
"FStar.UInt.logand",
"Vale.Def.Words_s.nat128",
"Vale.Def.Words_s.pow2_64",
"Vale.Def.Words_s.nat64",
"Vale.Poly1305.Math.lowerUpper128",
"FStar.Pervasives.assert_norm",
"Spec.Poly1305.felem",
"Spec.Poly1305.poly1305_encode_r",
"Vale.Poly1305.Equiv.to_felem",
"Prims.b2t",
"Prims.op_LessThan",
"Vale.Poly1305.Equiv.prime",
"Lib.IntTypes.int_t",
"Vale.Poly1305.Equiv.logand",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Vale.Poly1305.Equiv.u64",
"Vale.Poly1305.Equiv.uint_from_bytes_le",
"Vale.Poly1305.Equiv.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Spec.Poly1305.size_block",
"Vale.Poly1305.Equiv.nat_from_bytes_le",
"Spec.Poly1305.block",
"FStar.Seq.Base.slice",
"Prims.l_True",
"Prims.nat",
"Prims.l_or",
"Spec.Poly1305.prime",
"FStar.Seq.Base.seq",
"FStar.Pervasives.pattern"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul
unfold let to_felem = S.to_felem
unfold let modp = V.modp
unfold let mod2_128 = V.mod2_128
#set-options "--z3rlimit 150 --max_fuel 1 --max_ifuel 1"
let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma
(requires k <= length text / size_block)
(ensures (
let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0
))
(decreases k)
=
let inp = block_fun text in
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let repeat_f = repeat_blocks_f size_block text f nb in
let pad = pow2 (8 * size_block) in
assert_norm (pow2 128 + pow2 128 < prime);
if k = 0 then
Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0
else
(
let kk = k - 1 in
let hh = V.poly1305_hash_blocks acc0 pad r inp kk in
let r0:felem = repeati kk repeat_f acc0 in
let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in
calc (==) {
V.poly1305_hash_blocks acc0 pad r inp k;
== {}
modp ((hh + pad + inp kk) * r);
== {assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime)}
(hh + pad + inp kk) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime}
((hh + pad + inp kk) % prime) * r % prime;
== {lemma_poly1305_equiv_rec text acc0 r kk}
((pad + inp kk + r0) % prime) * r % prime;
== {assert_norm (fmul (fadd (pad + inp kk) r0) r == ((pad + inp kk + r0) % prime) * r % prime)}
fmul (fadd (pad + inp kk) r0) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime }
fmul (fadd (fadd pad (inp kk)) r0) r;
== {}
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
};
calc (==) {
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
== {}
f block (repeati kk repeat_f acc0);
== {}
repeat_f kk (repeati kk repeat_f acc0);
== {Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk}
repeati k repeat_f acc0;
}
)
let lemma_poly1305_equiv_last (text:bytes) (r:felem) (hBlocks:felem) : Lemma
(ensures (
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) == S.poly1305_update1 r nExtra last hBlocks
))
=
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
let x = nat_from_bytes_le last in
Math.Lemmas.pow2_le_compat 128 (8 * nExtra);
FStar.Math.Lemmas.modulo_lemma x padLast;
assert_norm (x + padLast < prime);
calc (==) {
modp ((hBlocks + padLast + inp nb % padLast) * r);
== {}
modp ((x + padLast + hBlocks) * r);
== {assert_norm (modp ((x + padLast + hBlocks) * r) == (x + padLast + hBlocks) * r % prime)}
(x + padLast + hBlocks) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (x + padLast + hBlocks) r prime}
((x + padLast + hBlocks) % prime) * r % prime;
== {assert_norm (((x + padLast + hBlocks) % prime) * r % prime == fmul (fadd (x + padLast) hBlocks) r)}
fmul (fadd (x + padLast) hBlocks) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (x + padLast) hBlocks prime }
fmul (fadd (fadd x padLast) hBlocks) r;
== {}
S.poly1305_update1 r nExtra last hBlocks;
}
let lemma_poly1305_equiv_r (k:key) : Lemma
(ensures (
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_poly1305_equiv_r (k: key)
: Lemma
(ensures
(let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes)) | [] | Vale.Poly1305.Equiv.lemma_poly1305_equiv_r | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k: Vale.Poly1305.Equiv.key
-> FStar.Pervasives.Lemma
(ensures
(let key_bytes = FStar.Seq.Base.slice k 0 16 in
let key_r = Vale.Poly1305.Equiv.nat_from_bytes_le key_bytes in
Vale.Poly1305.Equiv.iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff ==
Spec.Poly1305.poly1305_encode_r key_bytes)) | {
"end_col": 3,
"end_line": 174,
"start_col": 3,
"start_line": 129
} |
FStar.Pervasives.Lemma | val lemma_poly1305_equiv_last (text: bytes) (r hBlocks: felem)
: Lemma
(ensures
(let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) ==
S.poly1305_update1 r nExtra last hBlocks)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_poly1305_equiv_last (text:bytes) (r:felem) (hBlocks:felem) : Lemma
(ensures (
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) == S.poly1305_update1 r nExtra last hBlocks
))
=
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
let x = nat_from_bytes_le last in
Math.Lemmas.pow2_le_compat 128 (8 * nExtra);
FStar.Math.Lemmas.modulo_lemma x padLast;
assert_norm (x + padLast < prime);
calc (==) {
modp ((hBlocks + padLast + inp nb % padLast) * r);
== {}
modp ((x + padLast + hBlocks) * r);
== {assert_norm (modp ((x + padLast + hBlocks) * r) == (x + padLast + hBlocks) * r % prime)}
(x + padLast + hBlocks) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (x + padLast + hBlocks) r prime}
((x + padLast + hBlocks) % prime) * r % prime;
== {assert_norm (((x + padLast + hBlocks) % prime) * r % prime == fmul (fadd (x + padLast) hBlocks) r)}
fmul (fadd (x + padLast) hBlocks) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (x + padLast) hBlocks prime }
fmul (fadd (fadd x padLast) hBlocks) r;
== {}
S.poly1305_update1 r nExtra last hBlocks;
} | val lemma_poly1305_equiv_last (text: bytes) (r hBlocks: felem)
: Lemma
(ensures
(let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) ==
S.poly1305_update1 r nExtra last hBlocks))
let lemma_poly1305_equiv_last (text: bytes) (r hBlocks: felem)
: Lemma
(ensures
(let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) ==
S.poly1305_update1 r nExtra last hBlocks)) = | false | null | true | let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
let x = nat_from_bytes_le last in
Math.Lemmas.pow2_le_compat 128 (8 * nExtra);
FStar.Math.Lemmas.modulo_lemma x padLast;
assert_norm (x + padLast < prime);
calc ( == ) {
modp ((hBlocks + padLast + inp nb % padLast) * r);
( == ) { () }
modp ((x + padLast + hBlocks) * r);
( == ) { assert_norm (modp ((x + padLast + hBlocks) * r) == (x + padLast + hBlocks) * r % prime) }
(x + padLast + hBlocks) * r % prime;
( == ) { FStar.Math.Lemmas.lemma_mod_mul_distr_l (x + padLast + hBlocks) r prime }
((x + padLast + hBlocks) % prime) * r % prime;
( == ) { assert_norm (((x + padLast + hBlocks) % prime) * r % prime ==
fmul (fadd (x + padLast) hBlocks) r) }
fmul (fadd (x + padLast) hBlocks) r;
( == ) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (x + padLast) hBlocks prime }
fmul (fadd (fadd x padLast) hBlocks) r;
( == ) { () }
S.poly1305_update1 r nExtra last hBlocks;
} | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"lemma"
] | [
"Vale.Poly1305.Equiv.bytes",
"Vale.Poly1305.Equiv.felem",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Vale.Poly1305.Equiv.modp",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.op_Modulus",
"Spec.Poly1305.poly1305_update1",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Poly1305.Equiv.fmul",
"Vale.Poly1305.Equiv.fadd",
"Vale.Poly1305.Equiv.prime",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Pervasives.assert_norm",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.nat",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.Sequence.length",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Vale.Poly1305.Equiv.nat_from_bytes_le",
"Prims.pos",
"Vale.Poly1305.Equiv.size_block",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Lib.IntTypes.uint_t",
"Prims.op_Division",
"FStar.Seq.Base.length",
"Vale.Def.Words_s.nat128",
"Vale.Poly1305.Equiv.block_fun",
"Prims.l_True",
"FStar.Pervasives.pattern"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul
unfold let to_felem = S.to_felem
unfold let modp = V.modp
unfold let mod2_128 = V.mod2_128
#set-options "--z3rlimit 150 --max_fuel 1 --max_ifuel 1"
let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma
(requires k <= length text / size_block)
(ensures (
let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0
))
(decreases k)
=
let inp = block_fun text in
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let repeat_f = repeat_blocks_f size_block text f nb in
let pad = pow2 (8 * size_block) in
assert_norm (pow2 128 + pow2 128 < prime);
if k = 0 then
Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0
else
(
let kk = k - 1 in
let hh = V.poly1305_hash_blocks acc0 pad r inp kk in
let r0:felem = repeati kk repeat_f acc0 in
let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in
calc (==) {
V.poly1305_hash_blocks acc0 pad r inp k;
== {}
modp ((hh + pad + inp kk) * r);
== {assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime)}
(hh + pad + inp kk) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime}
((hh + pad + inp kk) % prime) * r % prime;
== {lemma_poly1305_equiv_rec text acc0 r kk}
((pad + inp kk + r0) % prime) * r % prime;
== {assert_norm (fmul (fadd (pad + inp kk) r0) r == ((pad + inp kk + r0) % prime) * r % prime)}
fmul (fadd (pad + inp kk) r0) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime }
fmul (fadd (fadd pad (inp kk)) r0) r;
== {}
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
};
calc (==) {
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
== {}
f block (repeati kk repeat_f acc0);
== {}
repeat_f kk (repeati kk repeat_f acc0);
== {Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk}
repeati k repeat_f acc0;
}
)
let lemma_poly1305_equiv_last (text:bytes) (r:felem) (hBlocks:felem) : Lemma
(ensures (
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) == S.poly1305_update1 r nExtra last hBlocks | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_poly1305_equiv_last (text: bytes) (r hBlocks: felem)
: Lemma
(ensures
(let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) ==
S.poly1305_update1 r nExtra last hBlocks)) | [] | Vale.Poly1305.Equiv.lemma_poly1305_equiv_last | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
text: Vale.Poly1305.Equiv.bytes ->
r: Vale.Poly1305.Equiv.felem ->
hBlocks: Vale.Poly1305.Equiv.felem
-> FStar.Pervasives.Lemma
(ensures
(let inp = Vale.Poly1305.Equiv.block_fun text in
let len = FStar.Seq.Base.length text in
let nb = len / Vale.Poly1305.Equiv.size_block in
let last = FStar.Seq.Base.slice text (nb * Vale.Poly1305.Equiv.size_block) len in
let nExtra = len % Vale.Poly1305.Equiv.size_block in
let padLast = Prims.pow2 (nExtra * 8) in
Vale.Poly1305.Equiv.modp ((hBlocks + padLast + inp nb % padLast) * r) ==
Spec.Poly1305.poly1305_update1 r nExtra last hBlocks)) | {
"end_col": 3,
"end_line": 121,
"start_col": 3,
"start_line": 96
} |
FStar.Pervasives.Lemma | val lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat)
: Lemma (requires k <= length text / size_block)
(ensures
(let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0))
(decreases k) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma
(requires k <= length text / size_block)
(ensures (
let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0
))
(decreases k)
=
let inp = block_fun text in
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let repeat_f = repeat_blocks_f size_block text f nb in
let pad = pow2 (8 * size_block) in
assert_norm (pow2 128 + pow2 128 < prime);
if k = 0 then
Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0
else
(
let kk = k - 1 in
let hh = V.poly1305_hash_blocks acc0 pad r inp kk in
let r0:felem = repeati kk repeat_f acc0 in
let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in
calc (==) {
V.poly1305_hash_blocks acc0 pad r inp k;
== {}
modp ((hh + pad + inp kk) * r);
== {assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime)}
(hh + pad + inp kk) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime}
((hh + pad + inp kk) % prime) * r % prime;
== {lemma_poly1305_equiv_rec text acc0 r kk}
((pad + inp kk + r0) % prime) * r % prime;
== {assert_norm (fmul (fadd (pad + inp kk) r0) r == ((pad + inp kk + r0) % prime) * r % prime)}
fmul (fadd (pad + inp kk) r0) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime }
fmul (fadd (fadd pad (inp kk)) r0) r;
== {}
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
};
calc (==) {
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
== {}
f block (repeati kk repeat_f acc0);
== {}
repeat_f kk (repeati kk repeat_f acc0);
== {Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk}
repeati k repeat_f acc0;
}
) | val lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat)
: Lemma (requires k <= length text / size_block)
(ensures
(let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0))
(decreases k)
let rec lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat)
: Lemma (requires k <= length text / size_block)
(ensures
(let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0))
(decreases k) = | false | null | true | let inp = block_fun text in
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let repeat_f = repeat_blocks_f size_block text f nb in
let pad = pow2 (8 * size_block) in
assert_norm (pow2 128 + pow2 128 < prime);
if k = 0
then Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0
else
(let kk = k - 1 in
let hh = V.poly1305_hash_blocks acc0 pad r inp kk in
let r0:felem = repeati kk repeat_f acc0 in
let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in
calc ( == ) {
V.poly1305_hash_blocks acc0 pad r inp k;
( == ) { () }
modp ((hh + pad + inp kk) * r);
( == ) { assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime) }
(hh + pad + inp kk) * r % prime;
( == ) { FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime }
((hh + pad + inp kk) % prime) * r % prime;
( == ) { lemma_poly1305_equiv_rec text acc0 r kk }
((pad + inp kk + r0) % prime) * r % prime;
( == ) { assert_norm (fmul (fadd (pad + inp kk) r0) r ==
((pad + inp kk + r0) % prime) * r % prime) }
fmul (fadd (pad + inp kk) r0) r;
( == ) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime }
fmul (fadd (fadd pad (inp kk)) r0) r;
( == ) { () }
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
};
calc ( == ) {
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
( == ) { () }
f block (repeati kk repeat_f acc0);
( == ) { () }
repeat_f kk (repeati kk repeat_f acc0);
( == ) { Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk }
repeati k repeat_f acc0;
}) | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"lemma",
""
] | [
"Vale.Poly1305.Equiv.bytes",
"Vale.Poly1305.Equiv.felem",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Spec.Poly1305.felem",
"Prims.bool",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Spec.Poly1305.poly1305_update1",
"Vale.Poly1305.Equiv.size_block",
"Vale.Poly1305.Equiv.repeati",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Lib.LoopCombinators.unfold_repeati",
"Vale.Poly1305.Spec_s.poly1305_hash_blocks",
"Vale.Poly1305.Equiv.fmul",
"Vale.Poly1305.Equiv.fadd",
"Prims.op_Addition",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Vale.Poly1305.Equiv.prime",
"Vale.Poly1305.Equiv.modp",
"FStar.Pervasives.assert_norm",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Vale.Poly1305.Equiv.lemma_poly1305_equiv_rec",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Seq.Base.seq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.slice",
"Lib.IntTypes.uint_t",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Vale.Poly1305.Equiv.repeat_blocks_f",
"Prims.op_Division",
"FStar.Seq.Base.length",
"Lib.Sequence.lseq",
"Spec.Poly1305.size_block",
"Vale.Def.Words_s.nat128",
"Vale.Poly1305.Equiv.block_fun",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.pattern"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul
unfold let to_felem = S.to_felem
unfold let modp = V.modp
unfold let mod2_128 = V.mod2_128
#set-options "--z3rlimit 150 --max_fuel 1 --max_ifuel 1"
let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma
(requires k <= length text / size_block)
(ensures (
let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0
)) | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_poly1305_equiv_rec (text: bytes) (acc0 r: felem) (k: nat)
: Lemma (requires k <= length text / size_block)
(ensures
(let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0))
(decreases k) | [
"recursion"
] | Vale.Poly1305.Equiv.lemma_poly1305_equiv_rec | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
text: Vale.Poly1305.Equiv.bytes ->
acc0: Vale.Poly1305.Equiv.felem ->
r: Vale.Poly1305.Equiv.felem ->
k: Prims.nat
-> FStar.Pervasives.Lemma
(requires k <= FStar.Seq.Base.length text / Vale.Poly1305.Equiv.size_block)
(ensures
(let f = Spec.Poly1305.poly1305_update1 r Vale.Poly1305.Equiv.size_block in
let repeat_f =
Vale.Poly1305.Equiv.repeat_blocks_f Vale.Poly1305.Equiv.size_block
text
f
(FStar.Seq.Base.length text / Vale.Poly1305.Equiv.size_block)
in
let pad = Prims.pow2 (8 * Vale.Poly1305.Equiv.size_block) in
Vale.Poly1305.Spec_s.poly1305_hash_blocks acc0
pad
r
(Vale.Poly1305.Equiv.block_fun text)
k ==
Vale.Poly1305.Equiv.repeati k repeat_f acc0))
(decreases k) | {
"end_col": 3,
"end_line": 84,
"start_col": 3,
"start_line": 42
} |
FStar.Pervasives.Lemma | val lemma_poly1305_equiv (text:bytes) (k:key) : Lemma
(ensures (
let inp = block_fun text in
let pad = pow2 (8 * size_block) in
let len = length text in
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let key_s:nat128 = nat_from_bytes_le (slice k 16 32) in
let v = V.poly1305_hash key_r key_s inp len in
0 <= v /\ v < pow2 128 /\
nat_to_bytes_le 16 v == S.poly1305_mac text k
)) | [
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Spec_s",
"short_module": "V"
},
{
"abbrev": true,
"full_module": "Spec.Poly1305",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_poly1305_equiv text k =
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let key_s:nat128 = nat_from_bytes_le (slice k 16 32) in
let r = S.poly1305_encode_r key_bytes in
lemma_poly1305_equiv_r k;
let acc0 = 0 in
let inp = block_fun text in
let pad = pow2 (8 * size_block) in
assert_norm (pad == pow2_128);
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let acc1 = repeati nb (repeat_blocks_f size_block text f nb) acc0 in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let l = S.poly1305_update_last r in
let repeat_f = repeat_blocks_f size_block text f nb in
let hBlocks = V.poly1305_hash_blocks acc0 pad r inp nb in
if nExtra = 0 then
(
lemma_poly1305_equiv_rec text acc0 r nb;
Lib.Sequence.lemma_repeat_blocks size_block text f l acc0;
calc (==) {
V.poly1305_hash key_r key_s inp len;
== {}
mod2_128 (hBlocks + key_s);
== {assert_norm (mod2_128 (hBlocks + key_s) == (hBlocks + key_s) % pow2 128)}
(hBlocks + key_s) % pow2 128;
};
calc (==) {
hBlocks <: int;
== {lemma_poly1305_equiv_rec text acc0 r nb}
repeati nb repeat_f acc0 <: felem;
};
calc (==) {
repeati nb repeat_f acc0;
== {}
l nExtra last acc1;
== {Lib.Sequence.lemma_repeat_blocks size_block text f l acc0}
repeat_blocks #uint8 #felem size_block text f l acc0;
== {}
S.poly1305_update text acc0 r;
};
calc (==) {
nat_to_bytes_le 16 (V.poly1305_hash key_r key_s inp len);
== {}
nat_to_bytes_le 16 ((S.poly1305_update text acc0 r + key_s) % pow2 128);
== {}
S.poly1305_mac text k;
};
()
)
else
(
lemma_poly1305_equiv_rec text acc0 r nb;
Lib.Sequence.lemma_repeat_blocks size_block text f l acc0;
let padLast = pow2 (nExtra * 8) in
let hLast = modp ((hBlocks + padLast + inp nb % padLast) * r) in
calc (==) {
V.poly1305_hash key_r key_s inp len;
== {}
mod2_128 (hLast + key_s);
== {assert_norm (mod2_128 (hLast + key_s) == (hLast + key_s) % pow2 128)}
(hLast + key_s) % pow2 128;
};
calc (==) {
hBlocks <: int;
== {lemma_poly1305_equiv_rec text acc0 r nb}
repeati nb repeat_f acc0 <: felem;
};
calc (==) {
S.poly1305_update1 r nExtra last (repeati nb repeat_f acc0);
== {}
l nExtra last acc1;
== {Lib.Sequence.lemma_repeat_blocks size_block text f l acc0}
repeat_blocks #uint8 #felem size_block text f l acc0;
== {}
S.poly1305_update text acc0 r;
};
lemma_poly1305_equiv_last text r hBlocks;
calc (==) {
nat_to_bytes_le 16 (V.poly1305_hash key_r key_s inp len);
== {}
nat_to_bytes_le 16 ((S.poly1305_update text acc0 r + key_s) % pow2 128);
== {}
S.poly1305_mac text k;
};
()
) | val lemma_poly1305_equiv (text:bytes) (k:key) : Lemma
(ensures (
let inp = block_fun text in
let pad = pow2 (8 * size_block) in
let len = length text in
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let key_s:nat128 = nat_from_bytes_le (slice k 16 32) in
let v = V.poly1305_hash key_r key_s inp len in
0 <= v /\ v < pow2 128 /\
nat_to_bytes_le 16 v == S.poly1305_mac text k
))
let lemma_poly1305_equiv text k = | false | null | true | let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let key_s:nat128 = nat_from_bytes_le (slice k 16 32) in
let r = S.poly1305_encode_r key_bytes in
lemma_poly1305_equiv_r k;
let acc0 = 0 in
let inp = block_fun text in
let pad = pow2 (8 * size_block) in
assert_norm (pad == pow2_128);
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let acc1 = repeati nb (repeat_blocks_f size_block text f nb) acc0 in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let l = S.poly1305_update_last r in
let repeat_f = repeat_blocks_f size_block text f nb in
let hBlocks = V.poly1305_hash_blocks acc0 pad r inp nb in
if nExtra = 0
then
(lemma_poly1305_equiv_rec text acc0 r nb;
Lib.Sequence.lemma_repeat_blocks size_block text f l acc0;
calc ( == ) {
V.poly1305_hash key_r key_s inp len;
( == ) { () }
mod2_128 (hBlocks + key_s);
( == ) { assert_norm (mod2_128 (hBlocks + key_s) == (hBlocks + key_s) % pow2 128) }
(hBlocks + key_s) % pow2 128;
};
calc ( == ) {
hBlocks <: int;
( == ) { lemma_poly1305_equiv_rec text acc0 r nb }
repeati nb repeat_f acc0 <: felem;
};
calc ( == ) {
repeati nb repeat_f acc0;
( == ) { () }
l nExtra last acc1;
( == ) { Lib.Sequence.lemma_repeat_blocks size_block text f l acc0 }
repeat_blocks #uint8 #felem size_block text f l acc0;
( == ) { () }
S.poly1305_update text acc0 r;
};
calc ( == ) {
nat_to_bytes_le 16 (V.poly1305_hash key_r key_s inp len);
( == ) { () }
nat_to_bytes_le 16 ((S.poly1305_update text acc0 r + key_s) % pow2 128);
( == ) { () }
S.poly1305_mac text k;
};
())
else
(lemma_poly1305_equiv_rec text acc0 r nb;
Lib.Sequence.lemma_repeat_blocks size_block text f l acc0;
let padLast = pow2 (nExtra * 8) in
let hLast = modp ((hBlocks + padLast + inp nb % padLast) * r) in
calc ( == ) {
V.poly1305_hash key_r key_s inp len;
( == ) { () }
mod2_128 (hLast + key_s);
( == ) { assert_norm (mod2_128 (hLast + key_s) == (hLast + key_s) % pow2 128) }
(hLast + key_s) % pow2 128;
};
calc ( == ) {
hBlocks <: int;
( == ) { lemma_poly1305_equiv_rec text acc0 r nb }
repeati nb repeat_f acc0 <: felem;
};
calc ( == ) {
S.poly1305_update1 r nExtra last (repeati nb repeat_f acc0);
( == ) { () }
l nExtra last acc1;
( == ) { Lib.Sequence.lemma_repeat_blocks size_block text f l acc0 }
repeat_blocks #uint8 #felem size_block text f l acc0;
( == ) { () }
S.poly1305_update text acc0 r;
};
lemma_poly1305_equiv_last text r hBlocks;
calc ( == ) {
nat_to_bytes_le 16 (V.poly1305_hash key_r key_s inp len);
( == ) { () }
nat_to_bytes_le 16 ((S.poly1305_update text acc0 r + key_s) % pow2 128);
( == ) { () }
S.poly1305_mac text k;
};
()) | {
"checked_file": "Vale.Poly1305.Equiv.fst.checked",
"dependencies": [
"Vale.Poly1305.Math.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Poly1305.Equiv.fst"
} | [
"lemma"
] | [
"Vale.Poly1305.Equiv.bytes",
"Vale.Poly1305.Equiv.key",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"FStar.Calc.calc_finish",
"Lib.Sequence.seq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"Lib.Sequence.length",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Vale.Poly1305.Spec_s.poly1305_hash",
"Lib.ByteSequence.nat_from_intseq_le",
"Vale.Poly1305.Equiv.nat_to_bytes_le",
"Spec.Poly1305.poly1305_mac",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"Prims.op_Addition",
"Spec.Poly1305.poly1305_update",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Spec.Poly1305.felem",
"Vale.Poly1305.Equiv.repeati",
"Vale.Poly1305.Equiv.repeat_blocks",
"Vale.Poly1305.Equiv.uint8",
"Vale.Poly1305.Equiv.felem",
"Vale.Poly1305.Equiv.size_block",
"Lib.Sequence.lemma_repeat_blocks",
"Lib.IntTypes.uint_t",
"Vale.Poly1305.Equiv.lemma_poly1305_equiv_rec",
"Vale.Poly1305.Equiv.mod2_128",
"FStar.Pervasives.assert_norm",
"Prims.bool",
"Vale.Poly1305.Equiv.lemma_poly1305_equiv_last",
"Spec.Poly1305.poly1305_update1",
"Vale.Poly1305.Equiv.modp",
"FStar.Mul.op_Star",
"Prims.pos",
"Vale.Poly1305.Spec_s.poly1305_hash_blocks",
"Vale.Poly1305.Equiv.repeat_blocks_f",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Lib.Sequence.lseq",
"Spec.Poly1305.poly1305_update_last",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.op_Division",
"FStar.Seq.Base.length",
"Spec.Poly1305.size_block",
"Vale.Poly1305.Equiv.pow2_128",
"Vale.Def.Words_s.nat128",
"Vale.Poly1305.Equiv.block_fun",
"Vale.Poly1305.Equiv.lemma_poly1305_equiv_r",
"Spec.Poly1305.poly1305_encode_r",
"Vale.Poly1305.Equiv.nat_from_bytes_le"
] | [] | module Vale.Poly1305.Equiv
open FStar.Mul
module BSeq = Lib.ByteSequence
// REVIEW: S and V use different smtencoding flags,
// so some equalities between S and V definitions aren't as obvious to Z3 as we might want.
unfold let pow2_128 = Vale.Def.Words_s.pow2_128
unfold let nat64 = Vale.Def.Words_s.nat64
unfold let iand #n = Vale.Def.Types_s.iand #n
unfold let size_nat = Lib.IntTypes.size_nat
unfold let uint_v #t #l = Lib.IntTypes.uint_v #t #l
unfold let uint8 = Lib.IntTypes.uint8
unfold let u64 = Lib.IntTypes.u64
unfold let logand #t #l = Lib.IntTypes.logand #t #l
unfold let repeati = Lib.LoopCombinators.repeati
unfold let repeat_blocks = Lib.Sequence.repeat_blocks
unfold let repeat_blocks_f = Lib.Sequence.repeat_blocks_f
unfold let sub #a #len = Lib.Sequence.sub #a #len
unfold let lbytes = Lib.ByteSequence.lbytes
unfold let uint_from_bytes_le #t #l = Lib.ByteSequence.uint_from_bytes_le #t #l
unfold let prime = S.prime
unfold let felem = S.felem
unfold let fadd = S.fadd
unfold let fmul = S.fmul
unfold let to_felem = S.to_felem
unfold let modp = V.modp
unfold let mod2_128 = V.mod2_128
#set-options "--z3rlimit 150 --max_fuel 1 --max_ifuel 1"
let rec lemma_poly1305_equiv_rec (text:bytes) (acc0:felem) (r:felem) (k:nat) : Lemma
(requires k <= length text / size_block)
(ensures (
let f = S.poly1305_update1 r size_block in
let repeat_f = repeat_blocks_f size_block text f (length text / size_block) in
let pad = pow2 (8 * size_block) in
V.poly1305_hash_blocks acc0 pad r (block_fun text) k == repeati k repeat_f acc0
))
(decreases k)
=
let inp = block_fun text in
let f = S.poly1305_update1 r size_block in
let len = length text in
let nb = len / size_block in
let repeat_f = repeat_blocks_f size_block text f nb in
let pad = pow2 (8 * size_block) in
assert_norm (pow2 128 + pow2 128 < prime);
if k = 0 then
Lib.LoopCombinators.eq_repeati0 nb repeat_f acc0
else
(
let kk = k - 1 in
let hh = V.poly1305_hash_blocks acc0 pad r inp kk in
let r0:felem = repeati kk repeat_f acc0 in
let block = Seq.slice text (kk * size_block) (kk * size_block + size_block) in
calc (==) {
V.poly1305_hash_blocks acc0 pad r inp k;
== {}
modp ((hh + pad + inp kk) * r);
== {assert_norm (modp ((hh + pad + inp kk) * r) == (hh + pad + inp kk) * r % prime)}
(hh + pad + inp kk) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (hh + pad + inp kk) r prime}
((hh + pad + inp kk) % prime) * r % prime;
== {lemma_poly1305_equiv_rec text acc0 r kk}
((pad + inp kk + r0) % prime) * r % prime;
== {assert_norm (fmul (fadd (pad + inp kk) r0) r == ((pad + inp kk + r0) % prime) * r % prime)}
fmul (fadd (pad + inp kk) r0) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (pad + inp kk) r0 prime }
fmul (fadd (fadd pad (inp kk)) r0) r;
== {}
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
};
calc (==) {
S.poly1305_update1 r size_block block (repeati kk repeat_f acc0);
== {}
f block (repeati kk repeat_f acc0);
== {}
repeat_f kk (repeati kk repeat_f acc0);
== {Lib.LoopCombinators.unfold_repeati nb repeat_f acc0 kk}
repeati k repeat_f acc0;
}
)
let lemma_poly1305_equiv_last (text:bytes) (r:felem) (hBlocks:felem) : Lemma
(ensures (
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
modp ((hBlocks + padLast + inp nb % padLast) * r) == S.poly1305_update1 r nExtra last hBlocks
))
=
let inp = block_fun text in
let len = length text in
let nb = len / size_block in
let last = Seq.slice text (nb * size_block) len in
let nExtra = len % size_block in
let padLast = pow2 (nExtra * 8) in
let x = nat_from_bytes_le last in
Math.Lemmas.pow2_le_compat 128 (8 * nExtra);
FStar.Math.Lemmas.modulo_lemma x padLast;
assert_norm (x + padLast < prime);
calc (==) {
modp ((hBlocks + padLast + inp nb % padLast) * r);
== {}
modp ((x + padLast + hBlocks) * r);
== {assert_norm (modp ((x + padLast + hBlocks) * r) == (x + padLast + hBlocks) * r % prime)}
(x + padLast + hBlocks) * r % prime;
== {FStar.Math.Lemmas.lemma_mod_mul_distr_l (x + padLast + hBlocks) r prime}
((x + padLast + hBlocks) % prime) * r % prime;
== {assert_norm (((x + padLast + hBlocks) % prime) * r % prime == fmul (fadd (x + padLast) hBlocks) r)}
fmul (fadd (x + padLast) hBlocks) r;
== { FStar.Math.Lemmas.lemma_mod_plus_distr_l (x + padLast) hBlocks prime }
fmul (fadd (fadd x padLast) hBlocks) r;
== {}
S.poly1305_update1 r nExtra last hBlocks;
}
let lemma_poly1305_equiv_r (k:key) : Lemma
(ensures (
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
iand key_r 0x0ffffffc0ffffffc0ffffffc0fffffff == S.poly1305_encode_r key_bytes
))
=
let key_bytes:S.block = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let mask = 0x0ffffffc0ffffffc0ffffffc0fffffff in
let rv = iand key_r mask in
let lo = uint_from_bytes_le (sub key_bytes 0 8) in
let hi = uint_from_bytes_le (sub key_bytes 8 8) in
let mask0 = u64 0x0ffffffc0fffffff in
let mask1 = u64 0x0ffffffc0ffffffc in
let mlo = logand lo mask0 in
let mhi = logand hi mask1 in
assert_norm (pow2 128 < prime);
let rs:felem = to_felem (uint_v mhi * pow2 64 + uint_v mlo) in
assert_norm (rs == S.poly1305_encode_r key_bytes);
let v_mask0:nat64 = 0x0ffffffc0fffffff in
let v_mask1:nat64 = 0x0ffffffc0ffffffc in
let v_lo:nat64 = uint_v lo in
let v_hi:nat64 = uint_v hi in
let lowerUpper128 = Vale.Poly1305.Math.lowerUpper128 in
let v_lo_hi:nat128 = lowerUpper128 v_lo v_hi in
let v_mask_0_1:nat128 = lowerUpper128 v_mask0 v_mask1 in
let z0 = iand v_lo v_mask0 in
let z1 = iand v_hi v_mask1 in
let z = lowerUpper128 z0 z1 in
let and64 = UInt.logand #64 in
calc (==) {
rv;
== {}
iand key_r mask;
== {Hacl.Impl.Poly1305.Lemmas.uint_from_bytes_le_lemma key_bytes}
iand (pow2 64 * v_hi + v_lo) mask;
== {Vale.Poly1305.Math.lowerUpper128_reveal ()}
iand v_lo_hi v_mask_0_1;
== {Vale.Poly1305.Math.lemma_lowerUpper128_and v_lo_hi v_lo v_hi v_mask_0_1 v_mask0 v_mask1 z z0 z1}
z;
== {Vale.Poly1305.Math.lowerUpper128_reveal ()}
z1 * pow2 64 + z0;
== {Vale.Arch.TypesNative.reveal_iand_all 64}
and64 v_hi v_mask1 * pow2 64 + and64 v_lo v_mask0;
== {Lib.IntTypes.logand_spec hi mask1; Lib.IntTypes.logand_spec lo mask0}
uint_v mhi * pow2 64 + uint_v mlo;
== {}
rs;
} | false | false | Vale.Poly1305.Equiv.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_poly1305_equiv (text:bytes) (k:key) : Lemma
(ensures (
let inp = block_fun text in
let pad = pow2 (8 * size_block) in
let len = length text in
let key_bytes = slice k 0 16 in
let key_r:nat128 = nat_from_bytes_le key_bytes in
let key_s:nat128 = nat_from_bytes_le (slice k 16 32) in
let v = V.poly1305_hash key_r key_s inp len in
0 <= v /\ v < pow2 128 /\
nat_to_bytes_le 16 v == S.poly1305_mac text k
)) | [] | Vale.Poly1305.Equiv.lemma_poly1305_equiv | {
"file_name": "vale/code/crypto/poly1305/Vale.Poly1305.Equiv.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | text: Vale.Poly1305.Equiv.bytes -> k: Vale.Poly1305.Equiv.key
-> FStar.Pervasives.Lemma
(ensures
(let inp = Vale.Poly1305.Equiv.block_fun text in
let pad = Prims.pow2 (8 * Vale.Poly1305.Equiv.size_block) in
let len = FStar.Seq.Base.length text in
let key_bytes = FStar.Seq.Base.slice k 0 16 in
let key_r = Vale.Poly1305.Equiv.nat_from_bytes_le key_bytes in
let key_s = Vale.Poly1305.Equiv.nat_from_bytes_le (FStar.Seq.Base.slice k 16 32) in
let v = Vale.Poly1305.Spec_s.poly1305_hash key_r key_s inp len in
0 <= v /\ v < Prims.pow2 128 /\
Vale.Poly1305.Equiv.nat_to_bytes_le 16 v == Spec.Poly1305.poly1305_mac text k)) | {
"end_col": 3,
"end_line": 265,
"start_col": 33,
"start_line": 176
} |
FStar.HyperStack.ST.Stack | val point_decompress:
out:point
-> s:lbuffer uint8 32ul ->
Stack bool
(requires fun h -> live h out /\ live h s)
(ensures fun h0 b h1 -> modifies (loc out) h0 h1 /\
(b ==> F51.point_inv_t h1 out) /\
(b <==> Some? (Spec.Ed25519.point_decompress (as_seq h0 s))) /\
(b ==> (F51.point_eval h1 out == Some?.v (Spec.Ed25519.point_decompress (as_seq h0 s))))
) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_decompress out s =
push_frame();
let tmp = create 10ul (u64 0) in
let res = point_decompress_ out s tmp in
pop_frame();
res | val point_decompress:
out:point
-> s:lbuffer uint8 32ul ->
Stack bool
(requires fun h -> live h out /\ live h s)
(ensures fun h0 b h1 -> modifies (loc out) h0 h1 /\
(b ==> F51.point_inv_t h1 out) /\
(b <==> Some? (Spec.Ed25519.point_decompress (as_seq h0 s))) /\
(b ==> (F51.point_eval h1 out == Some?.v (Spec.Ed25519.point_decompress (as_seq h0 s))))
)
let point_decompress out s = | true | null | false | push_frame ();
let tmp = create 10ul (u64 0) in
let res = point_decompress_ out s tmp in
pop_frame ();
res | {
"checked_file": "Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.RecoverX.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointDecompress.fst"
} | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Hacl.Impl.Ed25519.PointDecompress.point_decompress_",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | module Hacl.Impl.Ed25519.PointDecompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
module SE = Spec.Ed25519
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextract
val most_significant_bit:
s:lbuffer uint8 32ul ->
Stack uint64
(requires fun h -> live h s)
(ensures fun h0 z h1 -> h0 == h1 /\
(v z = 0 \/ v z = 1) /\
v z == (nat_from_bytes_le (as_seq h0 s) / pow2 255) % 2
)
open FStar.Calc
let most_significant_bit s =
let s31 = s.(31ul) in
let z = s31 >>. 7ul in
(**) let h0 = ST.get() in
(**) FStar.Math.Lemmas.lemma_div_lt_nat (v s31) 8 7;
(**) uints_from_bytes_le_nat_lemma #U8 #SEC #32 (as_seq h0 s);
(**) nat_from_intseq_le_slice_lemma (as_seq h0 s) 31;
(**) nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 s) 31 32);
(**) assert_norm (31 * 8 == 248);
(**) FStar.Math.Lemmas.lemma_div_mod_plus (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31))
(v s31) (pow2 248);
(**) FStar.Math.Lemmas.small_div (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31)) (pow2 248);
(**) FStar.Math.Lemmas.division_multiplication_lemma (nat_from_bytes_le (as_seq h0 s)) (pow2 248) (pow2 7);
(**) assert_norm (pow2 248 * pow2 7 = pow2 255);
(**) FStar.Math.Lemmas.small_mod (v s31 / pow2 7) 2;
to_u64 z
inline_for_extraction noextract
val point_decompress_:
out:point
-> s:lbuffer uint8 32ul
-> tmp:lbuffer uint64 10ul ->
Stack bool
(requires fun h ->
live h out /\ live h s /\ live h tmp /\
disjoint s tmp /\ disjoint out tmp /\
F51.mul_inv_t h (gsub tmp 5ul 5ul)
)
(ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
(b <==> Some? (SE.point_decompress (as_seq h0 s))) /\
(b ==> F51.point_inv_t h1 out) /\
(b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s))))
)
#push-options "--z3rlimit 50"
let point_decompress_ out s tmp =
let y = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let sign = most_significant_bit s in
load_51 y s;
let z = Hacl.Impl.Ed25519.RecoverX.recover_x x y sign in
let res =
if z = false then false
else (
let outx = getx out in
let outy = gety out in
let outz = getz out in
let outt = gett out in
copy outx x;
copy outy y;
make_one outz;
fmul outt x y;
true
) in
res
val point_decompress:
out:point
-> s:lbuffer uint8 32ul ->
Stack bool
(requires fun h -> live h out /\ live h s)
(ensures fun h0 b h1 -> modifies (loc out) h0 h1 /\
(b ==> F51.point_inv_t h1 out) /\
(b <==> Some? (Spec.Ed25519.point_decompress (as_seq h0 s))) /\
(b ==> (F51.point_eval h1 out == Some?.v (Spec.Ed25519.point_decompress (as_seq h0 s))))
) | false | false | Hacl.Impl.Ed25519.PointDecompress.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_decompress:
out:point
-> s:lbuffer uint8 32ul ->
Stack bool
(requires fun h -> live h out /\ live h s)
(ensures fun h0 b h1 -> modifies (loc out) h0 h1 /\
(b ==> F51.point_inv_t h1 out) /\
(b <==> Some? (Spec.Ed25519.point_decompress (as_seq h0 s))) /\
(b ==> (F51.point_eval h1 out == Some?.v (Spec.Ed25519.point_decompress (as_seq h0 s))))
) | [] | Hacl.Impl.Ed25519.PointDecompress.point_decompress | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointDecompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | out: Hacl.Bignum25519.point -> s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 5,
"end_line": 107,
"start_col": 2,
"start_line": 103
} |
FStar.HyperStack.ST.Stack | val point_decompress_:
out:point
-> s:lbuffer uint8 32ul
-> tmp:lbuffer uint64 10ul ->
Stack bool
(requires fun h ->
live h out /\ live h s /\ live h tmp /\
disjoint s tmp /\ disjoint out tmp /\
F51.mul_inv_t h (gsub tmp 5ul 5ul)
)
(ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
(b <==> Some? (SE.point_decompress (as_seq h0 s))) /\
(b ==> F51.point_inv_t h1 out) /\
(b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s))))
) | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.Ed25519",
"short_module": "SE"
},
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "SC"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_decompress_ out s tmp =
let y = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let sign = most_significant_bit s in
load_51 y s;
let z = Hacl.Impl.Ed25519.RecoverX.recover_x x y sign in
let res =
if z = false then false
else (
let outx = getx out in
let outy = gety out in
let outz = getz out in
let outt = gett out in
copy outx x;
copy outy y;
make_one outz;
fmul outt x y;
true
) in
res | val point_decompress_:
out:point
-> s:lbuffer uint8 32ul
-> tmp:lbuffer uint64 10ul ->
Stack bool
(requires fun h ->
live h out /\ live h s /\ live h tmp /\
disjoint s tmp /\ disjoint out tmp /\
F51.mul_inv_t h (gsub tmp 5ul 5ul)
)
(ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
(b <==> Some? (SE.point_decompress (as_seq h0 s))) /\
(b ==> F51.point_inv_t h1 out) /\
(b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s))))
)
let point_decompress_ out s tmp = | true | null | false | let y = sub tmp 0ul 5ul in
let x = sub tmp 5ul 5ul in
let sign = most_significant_bit s in
load_51 y s;
let z = Hacl.Impl.Ed25519.RecoverX.recover_x x y sign in
let res =
if z = false
then false
else
(let outx = getx out in
let outy = gety out in
let outz = getz out in
let outt = gett out in
copy outx x;
copy outy y;
make_one outz;
fmul outt x y;
true)
in
res | {
"checked_file": "Hacl.Impl.Ed25519.PointDecompress.fst.checked",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Ed25519.RecoverX.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.PointDecompress.fst"
} | [] | [
"Hacl.Bignum25519.point",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint64",
"Prims.bool",
"Prims.op_Equality",
"Prims.unit",
"Hacl.Bignum25519.fmul",
"Hacl.Bignum25519.make_one",
"Lib.Buffer.copy",
"Lib.Buffer.MUT",
"Hacl.Bignum25519.felem",
"Hacl.Bignum25519.gett",
"Hacl.Bignum25519.getz",
"Hacl.Bignum25519.gety",
"Hacl.Bignum25519.getx",
"Hacl.Impl.Ed25519.RecoverX.recover_x",
"Hacl.Bignum25519.load_51",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Impl.Ed25519.PointDecompress.most_significant_bit",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | module Hacl.Impl.Ed25519.PointDecompress
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteSequence
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
module SE = Spec.Ed25519
#set-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextract
val most_significant_bit:
s:lbuffer uint8 32ul ->
Stack uint64
(requires fun h -> live h s)
(ensures fun h0 z h1 -> h0 == h1 /\
(v z = 0 \/ v z = 1) /\
v z == (nat_from_bytes_le (as_seq h0 s) / pow2 255) % 2
)
open FStar.Calc
let most_significant_bit s =
let s31 = s.(31ul) in
let z = s31 >>. 7ul in
(**) let h0 = ST.get() in
(**) FStar.Math.Lemmas.lemma_div_lt_nat (v s31) 8 7;
(**) uints_from_bytes_le_nat_lemma #U8 #SEC #32 (as_seq h0 s);
(**) nat_from_intseq_le_slice_lemma (as_seq h0 s) 31;
(**) nat_from_intseq_le_lemma0 (Seq.slice (as_seq h0 s) 31 32);
(**) assert_norm (31 * 8 == 248);
(**) FStar.Math.Lemmas.lemma_div_mod_plus (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31))
(v s31) (pow2 248);
(**) FStar.Math.Lemmas.small_div (nat_from_intseq_le (Seq.slice (as_seq h0 s) 0 31)) (pow2 248);
(**) FStar.Math.Lemmas.division_multiplication_lemma (nat_from_bytes_le (as_seq h0 s)) (pow2 248) (pow2 7);
(**) assert_norm (pow2 248 * pow2 7 = pow2 255);
(**) FStar.Math.Lemmas.small_mod (v s31 / pow2 7) 2;
to_u64 z
inline_for_extraction noextract
val point_decompress_:
out:point
-> s:lbuffer uint8 32ul
-> tmp:lbuffer uint64 10ul ->
Stack bool
(requires fun h ->
live h out /\ live h s /\ live h tmp /\
disjoint s tmp /\ disjoint out tmp /\
F51.mul_inv_t h (gsub tmp 5ul 5ul)
)
(ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
(b <==> Some? (SE.point_decompress (as_seq h0 s))) /\
(b ==> F51.point_inv_t h1 out) /\
(b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s))))
)
#push-options "--z3rlimit 50" | false | false | Hacl.Impl.Ed25519.PointDecompress.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_decompress_:
out:point
-> s:lbuffer uint8 32ul
-> tmp:lbuffer uint64 10ul ->
Stack bool
(requires fun h ->
live h out /\ live h s /\ live h tmp /\
disjoint s tmp /\ disjoint out tmp /\
F51.mul_inv_t h (gsub tmp 5ul 5ul)
)
(ensures fun h0 b h1 -> modifies (loc out |+| loc tmp) h0 h1 /\
(b <==> Some? (SE.point_decompress (as_seq h0 s))) /\
(b ==> F51.point_inv_t h1 out) /\
(b ==> (F51.point_eval h1 out == Some?.v (SE.point_decompress (as_seq h0 s))))
) | [] | Hacl.Impl.Ed25519.PointDecompress.point_decompress_ | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.PointDecompress.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Hacl.Bignum25519.point ->
s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
tmp: Lib.Buffer.lbuffer Lib.IntTypes.uint64 10ul
-> FStar.HyperStack.ST.Stack Prims.bool | {
"end_col": 5,
"end_line": 88,
"start_col": 33,
"start_line": 68
} |
FStar.Pervasives.Lemma | val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul_r5_fits_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_fits_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp | val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_fits_lemma #w f1 r r5 = | false | null | true | let tmp = mul_felem5 f1 r r5 in
mul_felem5_fits_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Hacl.Poly1305.Field32xN.Lemmas1.carry_wide_felem5_fits_lemma",
"Hacl.Spec.Poly1305.Field32xN.carry_wide_felem5",
"Prims.unit",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.mul_felem5_fits_lemma",
"Hacl.Spec.Poly1305.Field32xN.felem_wide5",
"Hacl.Spec.Poly1305.Field32xN.mul_felem5"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34)
val mul_felem5_eval_lemma_i:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r}
-> i:nat{i < w} ->
Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i])
let mul_felem5_eval_lemma_i #w f1 r r5 i =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] ==
(uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] +
(uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] +
(uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] +
(uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] +
(uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
mul_felem5_eval_as_tup64 #w f1 r r5 i;
mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i)
val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_eval_lemma #w f1 r r5 =
let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp
val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r5_fits_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f1 (3, 3, 3, 3, 3)} ->
r:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r (2, 2, 2, 2, 2)} ->
r5:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r5 (10, 10, 10, 10, 10)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.felem_fits5 (Hacl.Spec.Poly1305.Field32xN.fmul_r5 f1 r r5)
(1, 2, 1, 1, 2)) [SMTPat (Hacl.Spec.Poly1305.Field32xN.fmul_r5 f1 r r5)] | {
"end_col": 37,
"end_line": 198,
"start_col": 35,
"start_line": 194
} |
FStar.Pervasives.Lemma | val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fmul_r5_eval_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_eval_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp | val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_eval_lemma #w f1 r r5 = | false | null | true | let tmp = mul_felem5 f1 r r5 in
mul_felem5_eval_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_and",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.precomp_r5",
"Hacl.Poly1305.Field32xN.Lemmas1.carry_wide_felem5_eval_lemma",
"Hacl.Spec.Poly1305.Field32xN.carry_wide_felem5",
"Prims.unit",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.mul_felem5_eval_lemma",
"Hacl.Spec.Poly1305.Field32xN.felem_wide5",
"Hacl.Spec.Poly1305.Field32xN.mul_felem5"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34)
val mul_felem5_eval_lemma_i:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r}
-> i:nat{i < w} ->
Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i])
let mul_felem5_eval_lemma_i #w f1 r r5 i =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] ==
(uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] +
(uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] +
(uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] +
(uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] +
(uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
mul_felem5_eval_as_tup64 #w f1 r r5 i;
mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i)
val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_eval_lemma #w f1 r r5 =
let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp
val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_fits_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_fits_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp
val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.fmul_r5_eval_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f1 (3, 3, 3, 3, 3)} ->
r:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r (2, 2, 2, 2, 2)} ->
r5:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{ Hacl.Spec.Poly1305.Field32xN.felem_fits5 r5 (10, 10, 10, 10, 10) /\
r5 == Hacl.Spec.Poly1305.Field32xN.precomp_r5 r }
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.feval5 (Hacl.Spec.Poly1305.Field32xN.fmul_r5 f1 r r5) ==
Lib.Sequence.map2 Hacl.Spec.Poly1305.Vec.pfmul
(Hacl.Spec.Poly1305.Field32xN.feval5 f1)
(Hacl.Spec.Poly1305.Field32xN.feval5 r))
[SMTPat (Hacl.Spec.Poly1305.Field32xN.fmul_r5 f1 r r5)] | {
"end_col": 37,
"end_line": 213,
"start_col": 35,
"start_line": 209
} |
FStar.Pervasives.Lemma | val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_felem5_eval_lemma #w f1 r r5 =
let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp | val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_eval_lemma #w f1 r r5 = | false | null | true | let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.l_and",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.precomp_r5",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Poly1305.Vec.pfelem",
"Hacl.Spec.Poly1305.Field32xN.feval5",
"Hacl.Spec.Poly1305.Field32xN.mul_felem5",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Poly1305.Vec.pfmul",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.mul_felem5_eval_lemma_i",
"Lib.Sequence.lseq",
"Prims.l_Forall",
"Prims.l_imp",
"Lib.Sequence.index",
"Lib.Sequence.map2"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34)
val mul_felem5_eval_lemma_i:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r}
-> i:nat{i < w} ->
Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i])
let mul_felem5_eval_lemma_i #w f1 r r5 i =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] ==
(uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] +
(uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] +
(uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] +
(uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] +
(uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
mul_felem5_eval_as_tup64 #w f1 r r5 i;
mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i)
val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.mul_felem5_eval_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f1 (3, 3, 3, 3, 3)} ->
r:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r (2, 2, 2, 2, 2)} ->
r5:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{ Hacl.Spec.Poly1305.Field32xN.felem_fits5 r5 (10, 10, 10, 10, 10) /\
r5 == Hacl.Spec.Poly1305.Field32xN.precomp_r5 r }
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.feval5 (Hacl.Spec.Poly1305.Field32xN.mul_felem5 f1 r r5) ==
Lib.Sequence.map2 Hacl.Spec.Poly1305.Vec.pfmul
(Hacl.Spec.Poly1305.Field32xN.feval5 f1)
(Hacl.Spec.Poly1305.Field32xN.feval5 r))
[SMTPat (Hacl.Spec.Poly1305.Field32xN.mul_felem5 f1 r r5)] | {
"end_col": 47,
"end_line": 183,
"start_col": 38,
"start_line": 180
} |
FStar.Pervasives.Lemma | val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) | val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 = | false | null | true | let r0, r1, r2, r3, r4 = r in
let f10, f11, f12, f13, f14 = f1 in
let r50, r51, r52, r53, r54 = r5 in
let a0, a1, a2, a3, a4 = smul_felem5 #w f10 (r0, r1, r2, r3, r4) in
smul_felem5_fits_lemma #w #3 #(2, 2, 2, 2, 2) f10 (r0, r1, r2, r3, r4);
let a10, a11, a12, a13, a14 = smul_add_felem5 #w f11 (r54, r0, r1, r2, r3) (a0, a1, a2, a3, a4) in
smul_add_felem5_fits_lemma #w
#3
#(10, 2, 2, 2, 2)
#(6, 6, 6, 6, 6)
f11
(r54, r0, r1, r2, r3)
(a0, a1, a2, a3, a4);
let a20, a21, a22, a23, a24 =
smul_add_felem5 #w f12 (r53, r54, r0, r1, r2) (a10, a11, a12, a13, a14)
in
smul_add_felem5_fits_lemma #w
#3
#(10, 10, 2, 2, 2)
#(36, 12, 12, 12, 12)
f12
(r53, r54, r0, r1, r2)
(a10, a11, a12, a13, a14);
let a30, a31, a32, a33, a34 =
smul_add_felem5 #w f13 (r52, r53, r54, r0, r1) (a20, a21, a22, a23, a24)
in
smul_add_felem5_fits_lemma #w
#3
#(10, 10, 10, 2, 2)
#(66, 42, 18, 18, 18)
f13
(r52, r53, r54, r0, r1)
(a20, a21, a22, a23, a24);
let a40, a41, a42, a43, a44 =
smul_add_felem5 #w f14 (r51, r52, r53, r54, r0) (a30, a31, a32, a33, a34)
in
smul_add_felem5_fits_lemma #w
#3
#(10, 10, 10, 10, 2)
#(96, 72, 48, 24, 24)
f14
(r51, r52, r53, r54, r0)
(a30, a31, a32, a33, a34) | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Hacl.Spec.Poly1305.Field32xN.uint64xN",
"Hacl.Poly1305.Field32xN.Lemmas0.smul_add_felem5_fits_lemma",
"Prims.unit",
"Hacl.Spec.Poly1305.Field32xN.felem_wide5",
"Hacl.Spec.Poly1305.Field32xN.smul_add_felem5",
"Hacl.Poly1305.Field32xN.Lemmas0.smul_felem5_fits_lemma",
"Hacl.Spec.Poly1305.Field32xN.smul_felem5"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.mul_felem5_fits_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f1 (3, 3, 3, 3, 3)} ->
r:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r (2, 2, 2, 2, 2)} ->
r5:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 r5 (10, 10, 10, 10, 10)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.felem_wide_fits5 (Hacl.Spec.Poly1305.Field32xN.mul_felem5 f1
r
r5)
(126, 102, 78, 54, 30)) [SMTPat (Hacl.Spec.Poly1305.Field32xN.mul_felem5 f1 r r5)] | {
"end_col": 116,
"end_line": 125,
"start_col": 38,
"start_line": 111
} |
FStar.Pervasives.Lemma | val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) | val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f = | false | null | true | FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f) | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_less5",
"Prims.pow2",
"FStar.Classical.forall_intro",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Prims.l_and",
"Spec.Poly1305.prime",
"Hacl.Spec.Poly1305.Vec.pfelem",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Hacl.Spec.Poly1305.Field32xN.feval5",
"Hacl.Spec.Poly1305.Field32xN.fas_nat5",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.lemma_feval_is_fas_nat_i",
"Prims.unit"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i]) | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.lemma_feval_is_fas_nat | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_less5 f (Prims.pow2 128)}
-> FStar.Pervasives.Lemma
(ensures
forall (i: Prims.nat).
i < w ==>
(Hacl.Spec.Poly1305.Field32xN.fas_nat5 f).[ i ] ==
(Hacl.Spec.Poly1305.Field32xN.feval5 f).[ i ]) | {
"end_col": 62,
"end_line": 35,
"start_col": 2,
"start_line": 35
} |
FStar.Pervasives.Lemma | val store_felem5_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (1, 1, 1, 1, 1)} ->
Lemma
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)
[SMTPat (store_felem5 f)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let store_felem5_lemma #w f =
store_felem5_lemma #w f | val store_felem5_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (1, 1, 1, 1, 1)} ->
Lemma
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)
[SMTPat (store_felem5 f)]
let store_felem5_lemma #w f = | false | null | true | store_felem5_lemma #w f | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Hacl.Poly1305.Field32xN.Lemmas2.store_felem5_lemma",
"Prims.unit"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34)
val mul_felem5_eval_lemma_i:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r}
-> i:nat{i < w} ->
Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i])
let mul_felem5_eval_lemma_i #w f1 r r5 i =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] ==
(uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] +
(uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] +
(uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] +
(uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] +
(uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
mul_felem5_eval_as_tup64 #w f1 r r5 i;
mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i)
val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_eval_lemma #w f1 r r5 =
let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp
val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_fits_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_fits_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp
val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_eval_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_eval_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp
val fadd_mul_r5_fits_lemma:
#w:lanes
-> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)}
-> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)}
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)}
-> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} ->
Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fadd_mul_r5 acc f1 r r5)]
let fadd_mul_r5_fits_lemma #w acc f1 r r5 =
let acc1 = fadd5 acc f1 in
fadd5_fits_lemma #w acc f1;
let tmp = mul_felem5 acc1 r r5 in
mul_felem5_fits_lemma #w acc1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp
val fadd_mul_r5_eval_lemma:
#w:lanes
-> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)}
-> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)}
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)}
-> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fadd_mul_r5 acc f1 r r5) ==
map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r))
[SMTPat (fadd_mul_r5 acc f1 r r5)]
let fadd_mul_r5_eval_lemma #w acc f1 r r5 =
let acc1 = fadd5 acc f1 in
fadd5_eval_lemma #w acc f1;
let tmp = mul_felem5 acc1 r r5 in
mul_felem5_eval_lemma #w acc1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp
val reduce_felem5_eval_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} ->
Lemma
(felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\
(feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0])
[SMTPat (reduce_felem5 f)]
let reduce_felem5_eval_lemma #w f =
carry_full_felem5_eval_lemma f;
carry_full_felem5_fits_lemma f;
let f = carry_full_felem5 f in
carry_reduce_felem5_lemma #w f;
subtract_p5_felem5_lemma #w (carry_full_felem5 f)
val fmul_r2_normalize50:
acc:felem5 2
-> r:felem5 2
-> r2:felem5 2 ->
Pure (felem5 2)
(requires
felem_fits5 acc (3, 3, 3, 3, 3) /\
felem_fits5 r (1, 1, 1, 1, 1) /\
felem_fits5 r2 (2, 2, 2, 2, 2) /\
feval5 r2 == Vec.compute_r2 (feval5 r).[0])
(ensures fun a ->
let fr21 = create2 (feval5 r2).[0] (feval5 r).[0] in
feval5 a == Vec.fmul (feval5 acc) fr21 /\
felem_fits5 a (1, 2, 1, 1, 2))
let fmul_r2_normalize50 (a0, a1, a2, a3, a4) (r0, r1, r2, r3, r4) (r20, r21, r22, r23, r24) =
let r210 = vec_interleave_low r20 r0 in
vec_interleave_low_lemma2 r20 r0;
let r211 = vec_interleave_low r21 r1 in
vec_interleave_low_lemma2 r21 r1;
let r212 = vec_interleave_low r22 r2 in
vec_interleave_low_lemma2 r22 r2;
let r213 = vec_interleave_low r23 r3 in
vec_interleave_low_lemma2 r23 r3;
let r214 = vec_interleave_low r24 r4 in
vec_interleave_low_lemma2 r24 r4;
let acc = (a0, a1, a2, a3, a4) in
let fr = (r0, r1, r2, r3, r4) in
let fr2 = (r20, r21, r22, r23, r24) in
assert ((feval5 fr2).[0] == Vec.pfmul ((feval5 fr).[0]) ((feval5 fr).[0]));
let fr21 = (r210, r211, r212, r213, r214) in
eq_intro (feval5 fr21) (create2 (feval5 fr2).[0] (feval5 fr).[0]);
assert (feval5 fr21 == create2 (feval5 fr2).[0] (feval5 fr).[0]);
assert (felem_fits5 fr21 (2, 2, 2, 2, 2));
let fr215 = precomp_r5 #2 fr21 in
let a = fmul_r5 #2 acc fr21 fr215 in
fmul_r5_eval_lemma acc fr21 fr215;
fmul_r5_fits_lemma acc fr21 fr215;
assert (feval5 a == Vec.fmul (feval5 acc) (feval5 fr21));
assert (felem_fits5 a (1, 2, 1, 1, 2));
a
#push-options "--z3rlimit 150"
val fmul_r2_normalize51:
a:felem5 2
-> fa1:felem5 2 ->
Pure (felem5 2)
(requires
felem_fits5 a (1, 2, 1, 1, 2) /\
felem_fits5 fa1 (1, 2, 1, 1, 2) /\
feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1])
(ensures fun out ->
(feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1] /\
felem_fits5 out (2, 4, 2, 2, 4))
let fmul_r2_normalize51 a fa1 =
let (a0, a1, a2, a3, a4) = a in
let (a10, a11, a12, a13, a14) = fa1 in
let o0 = vec_add_mod a0 a10 in
let o1 = vec_add_mod a1 a11 in
let o2 = vec_add_mod a2 a12 in
let o3 = vec_add_mod a3 a13 in
let o4 = vec_add_mod a4 a14 in
let out = (o0, o1, o2, o3, o4) in
let (a0, a1, a2, a3, a4) = as_tup64_i a 0 in
let (a10, a11, a12, a13, a14) = as_tup64_i fa1 0 in
let (o0, o1, o2, o3, o4) = as_tup64_i out 0 in
FStar.Math.Lemmas.modulo_lemma (v a0 + v a10) (pow2 64);
FStar.Math.Lemmas.modulo_lemma (v a1 + v a11) (pow2 64);
FStar.Math.Lemmas.modulo_lemma (v a2 + v a12) (pow2 64);
FStar.Math.Lemmas.modulo_lemma (v a3 + v a13) (pow2 64);
FStar.Math.Lemmas.modulo_lemma (v a4 + v a14) (pow2 64);
assert (felem_fits5 out (2, 4, 2, 2, 4));
calc (==) {
((feval5 a).[0] + (feval5 a).[1]) % Vec.prime;
(==) { }
(as_nat5 (a0, a1, a2, a3, a4) % Vec.prime + as_nat5 (a10, a11, a12, a13, a14) % Vec.prime) % Vec.prime;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l
(as_nat5 (a0, a1, a2, a3, a4)) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(as_nat5 (a0, a1, a2, a3, a4) % Vec.prime) (as_nat5 (a10, a11, a12, a13, a14)) Vec.prime }
(as_nat5 (a0, a1, a2, a3, a4) + as_nat5 (a10, a11, a12, a13, a14)) % Vec.prime;
(==) { }
(feval5 out).[0];
};
out
#pop-options
val fmul_r2_normalize5_lemma:
acc:felem5 2
-> r:felem5 2
-> r2:felem5 2 ->
Lemma
(requires
felem_fits5 acc (3, 3, 3, 3, 3) /\
felem_fits5 r (1, 1, 1, 1, 1) /\
felem_fits5 r2 (2, 2, 2, 2, 2) /\
feval5 r2 == Vec.compute_r2 (feval5 r).[0])
(ensures
(let out = fmul_r2_normalize5 acc r r2 in
felem_fits5 out (2, 1, 1, 1, 1) /\
(feval5 out).[0] == Vec.normalize_2 (feval5 r).[0] (feval5 acc)))
[SMTPat (fmul_r2_normalize5 acc r r2)]
let fmul_r2_normalize5_lemma acc r r2 =
let a = fmul_r2_normalize50 acc r r2 in
let (a0, a1, a2, a3, a4) = a in
let a10 = vec_interleave_high a0 a0 in
vec_interleave_high_lemma2 a0 a0;
let a11 = vec_interleave_high a1 a1 in
vec_interleave_high_lemma2 a1 a1;
let a12 = vec_interleave_high a2 a2 in
vec_interleave_high_lemma2 a2 a2;
let a13 = vec_interleave_high a3 a3 in
vec_interleave_high_lemma2 a3 a3;
let a14 = vec_interleave_high a4 a4 in
vec_interleave_high_lemma2 a4 a4;
let fa1 = (a10, a11, a12, a13, a14) in
eq_intro (feval5 fa1) (create2 (feval5 a).[1] (feval5 a).[1]);
assert (feval5 fa1 == create2 (feval5 a).[1] (feval5 a).[1]);
assert (felem_fits5 fa1 (1, 2, 1, 1, 2));
let out = fmul_r2_normalize51 a fa1 in
assert ((feval5 out).[0] == Vec.pfadd (feval5 a).[0] (feval5 a).[1]);
let res = carry_full_felem5 out in
carry_full_felem5_lemma out
val fmul_r4_normalize50:
acc:felem5 4
-> r:felem5 4
-> r2:felem5 4
-> r3:felem5 4
-> r4:felem5 4 ->
Pure (felem5 4)
(requires
felem_fits5 acc (3, 3, 3, 3, 3) /\
felem_fits5 r (1, 1, 1, 1, 1) /\
felem_fits5 r2 (2, 2, 2, 2, 2) /\
felem_fits5 r3 (2, 2, 2, 2, 2) /\
felem_fits5 r4 (2, 2, 2, 2, 2) /\
feval5 r2 == Vec.fmul (feval5 r) (feval5 r) /\
feval5 r3 == Vec.fmul (feval5 r2) (feval5 r) /\
feval5 r4 == Vec.compute_r4 (feval5 r).[0])
(ensures fun out ->
let fr4321 = create4 (feval5 r4).[0] (feval5 r3).[0] (feval5 r2).[0] (feval5 r).[0] in
feval5 out == Vec.fmul (feval5 acc) fr4321 /\
felem_fits5 out (1, 2, 1, 1, 2))
let fmul_r4_normalize50 acc fr fr2 fr3 fr4 =
let (r10, r11, r12, r13, r14) = fr in
let (r20, r21, r22, r23, r24) = fr2 in
let (r30, r31, r32, r33, r34) = fr3 in
let (r40, r41, r42, r43, r44) = fr4 in
let (a0, a1, a2, a3, a4) = acc in
let v12120 = vec_interleave_low r20 r10 in
vec_interleave_low_lemma_uint64_4 r20 r10;
let v34340 = vec_interleave_low r40 r30 in
vec_interleave_low_lemma_uint64_4 r40 r30;
let r12340 = vec_interleave_low_n 2 v34340 v12120 in
vec_interleave_low_n_lemma_uint64_4_2 v34340 v12120;
let v12121 = vec_interleave_low r21 r11 in
vec_interleave_low_lemma_uint64_4 r21 r11;
let v34341 = vec_interleave_low r41 r31 in
vec_interleave_low_lemma_uint64_4 r41 r31;
let r12341 = vec_interleave_low_n 2 v34341 v12121 in
vec_interleave_low_n_lemma_uint64_4_2 v34341 v12121;
let v12122 = vec_interleave_low r22 r12 in
vec_interleave_low_lemma_uint64_4 r22 r12;
let v34342 = vec_interleave_low r42 r32 in
vec_interleave_low_lemma_uint64_4 r42 r32;
let r12342 = vec_interleave_low_n 2 v34342 v12122 in
vec_interleave_low_n_lemma_uint64_4_2 v34342 v12122;
let v12123 = vec_interleave_low r23 r13 in
vec_interleave_low_lemma_uint64_4 r23 r13;
let v34343 = vec_interleave_low r43 r33 in
vec_interleave_low_lemma_uint64_4 r43 r33;
let r12343 = vec_interleave_low_n 2 v34343 v12123 in
vec_interleave_low_n_lemma_uint64_4_2 v34343 v12123;
let v12124 = vec_interleave_low r24 r14 in
vec_interleave_low_lemma_uint64_4 r24 r14;
let v34344 = vec_interleave_low r44 r34 in
vec_interleave_low_lemma_uint64_4 r44 r34;
let r12344 = vec_interleave_low_n 2 v34344 v12124 in
vec_interleave_low_n_lemma_uint64_4_2 v34344 v12124;
let fr1234 = (r12340, r12341, r12342, r12343, r12344) in
eq_intro (feval5 fr1234) (create4 (feval5 fr4).[0] (feval5 fr3).[0] (feval5 fr2).[0] (feval5 fr).[0]);
let fr12345 = precomp_r5 #4 fr1234 in
let out = fmul_r5 #4 acc fr1234 fr12345 in
fmul_r5_eval_lemma acc fr1234 fr12345;
fmul_r5_fits_lemma acc fr1234 fr12345;
out
val lemma_fmul_r4_normalize51:
#m:scale32{m <= 2}
-> o:uint64xN 4{felem_fits1 o m} ->
Lemma
(let v00 = vec_interleave_high_n 2 o o in
let v10 = vec_add_mod o v00 in
let v10h = vec_interleave_high v10 v10 in
let v20 = vec_add_mod v10 v10h in
felem_fits1 v20 (4 * m) /\
(uint64xN_v v20).[0] == (uint64xN_v o).[0] + (uint64xN_v o).[1] + (uint64xN_v o).[2] + (uint64xN_v o).[3])
let lemma_fmul_r4_normalize51 #m o =
let v00 = vec_interleave_high_n 2 o o in
vec_interleave_high_n_lemma_uint64_4_2 o o;
let (o0, o1, o2, o3) = ((vec_v o).[0], (vec_v o).[1], (vec_v o).[2], (vec_v o).[3]) in
assert (vec_v v00 == create4 o2 o3 o2 o3);
let v10 = vec_add_mod o v00 in
FStar.Math.Lemmas.modulo_lemma (v o0 + v o2) (pow2 64);
FStar.Math.Lemmas.modulo_lemma (v o1 + v o3) (pow2 64);
assert (v (vec_v v10).[0] == v o0 + v o2);
assert (v (vec_v v10).[1] == v o1 + v o3);
let v10h = vec_interleave_high v10 v10 in
vec_interleave_high_lemma_uint64_4 v10 v10;
assert (v (vec_v v10h).[0] == v (vec_v v10).[1]);
let v20 = vec_add_mod v10 v10h in
FStar.Math.Lemmas.modulo_lemma (v o0 + v o2 + v o1 + v o3) (pow2 64)
val lemma_fmul_r4_normalize51_expand:
v2:felem5 4
-> out:felem5 4 ->
Lemma
(requires
(let (v20, v21, v22, v23, v24) = v2 in
let (o0, o1, o2, o3, o4) = out in
(uint64xN_v v20).[0] == (uint64xN_v o0).[0] + (uint64xN_v o0).[1] + (uint64xN_v o0).[2] + (uint64xN_v o0).[3] /\
(uint64xN_v v21).[0] == (uint64xN_v o1).[0] + (uint64xN_v o1).[1] + (uint64xN_v o1).[2] + (uint64xN_v o1).[3] /\
(uint64xN_v v22).[0] == (uint64xN_v o2).[0] + (uint64xN_v o2).[1] + (uint64xN_v o2).[2] + (uint64xN_v o2).[3] /\
(uint64xN_v v23).[0] == (uint64xN_v o3).[0] + (uint64xN_v o3).[1] + (uint64xN_v o3).[2] + (uint64xN_v o3).[3] /\
(uint64xN_v v24).[0] == (uint64xN_v o4).[0] + (uint64xN_v o4).[1] + (uint64xN_v o4).[2] + (uint64xN_v o4).[3]))
(ensures
(let (v20, v21, v22, v23, v24) = v2 in
let (o0, o1, o2, o3, o4) = out in
(feval5 v2).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 out).[0] (feval5 out).[1]) (feval5 out).[2]) (feval5 out).[3]))
let lemma_fmul_r4_normalize51_expand v2 out =
let (v20, v21, v22, v23, v24) = as_tup64_i v2 0 in
let (o0, o1, o2, o3, o4) = out in
calc (==) {
as_nat5 (v20, v21, v22, v23, v24) % Vec.prime;
(==) { }
(as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1) + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1))
(as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) Vec.prime }
((as_nat5 (as_tup64_i out 0) + as_nat5 (as_tup64_i out 1)) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime;
(==) { FStar.Math.Lemmas.modulo_distributivity (as_nat5 (as_tup64_i out 0)) (as_nat5 (as_tup64_i out 1)) Vec.prime }
(((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2) + as_nat5 (as_tup64_i out 3)) % Vec.prime;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_l (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2))
(as_nat5 (as_tup64_i out 3)) Vec.prime }
((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + as_nat5 (as_tup64_i out 2)) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r (((feval5 out).[0] + (feval5 out).[1]) % Vec.prime) (as_nat5 (as_tup64_i out 2)) Vec.prime }
((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + as_nat5 (as_tup64_i out 3)) % Vec.prime;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r ((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime)
(as_nat5 (as_tup64_i out 3)) Vec.prime }
((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime;
};
assert ((feval5 v2).[0] ==
((((feval5 out).[0] + (feval5 out).[1]) % Vec.prime + (feval5 out).[2]) % Vec.prime + (feval5 out).[3]) % Vec.prime)
val fmul_r4_normalize51: a:felem5 4 ->
Pure (felem5 4)
(requires felem_fits5 a (1, 2, 1, 1, 2))
(ensures fun res ->
felem_fits5 res (4, 8, 4, 4, 8) /\
(feval5 res).[0] == Vec.pfadd (Vec.pfadd (Vec.pfadd (feval5 a).[0] (feval5 a).[1]) (feval5 a).[2]) (feval5 a).[3])
let fmul_r4_normalize51 fa =
let (o0, o1, o2, o3, o4) = fa in
let v00 = vec_interleave_high_n 2 o0 o0 in
let v10 = vec_add_mod o0 v00 in
let v10h = vec_interleave_high v10 v10 in
let v20 = vec_add_mod v10 v10h in
lemma_fmul_r4_normalize51 #1 o0;
let v01 = vec_interleave_high_n 2 o1 o1 in
let v11 = vec_add_mod o1 v01 in
let v11h = vec_interleave_high v11 v11 in
let v21 = vec_add_mod v11 v11h in
lemma_fmul_r4_normalize51 #2 o1;
let v02 = vec_interleave_high_n 2 o2 o2 in
let v12 = vec_add_mod o2 v02 in
let v12h = vec_interleave_high v12 v12 in
let v22 = vec_add_mod v12 v12h in
lemma_fmul_r4_normalize51 #1 o2;
let v03 = vec_interleave_high_n 2 o3 o3 in
let v13 = vec_add_mod o3 v03 in
let v13h = vec_interleave_high v13 v13 in
let v23 = vec_add_mod v13 v13h in
lemma_fmul_r4_normalize51 #1 o3;
let v04 = vec_interleave_high_n 2 o4 o4 in
let v14 = vec_add_mod o4 v04 in
let v14h = vec_interleave_high v14 v14 in
let v24 = vec_add_mod v14 v14h in
lemma_fmul_r4_normalize51 #2 o4;
let res = (v20, v21, v22, v23, v24) in
lemma_fmul_r4_normalize51_expand res fa;
res
val fmul_r4_normalize5_lemma:
acc:felem5 4
-> r:felem5 4
-> r_5:felem5 4
-> r4:felem5 4 ->
Lemma
(requires
felem_fits5 acc (3, 3, 3, 3, 3) /\
felem_fits5 r (1, 1, 1, 1, 1) /\
felem_fits5 r4 (2, 2, 2, 2, 2) /\
r_5 == precomp_r5 r /\
feval5 r4 == Vec.compute_r4 (feval5 r).[0])
(ensures
(let out = fmul_r4_normalize5 acc r r_5 r4 in
felem_fits5 out (2, 1, 1, 1, 1) /\
(feval5 out).[0] == Vec.normalize_4 (feval5 r).[0] (feval5 acc)))
[SMTPat (fmul_r4_normalize5 acc r r_5 r4)]
#restart-solver
#push-options "--z3rlimit 500"
let fmul_r4_normalize5_lemma acc fr fr_5 fr4 =
let fr2 = fmul_r5 #4 fr fr fr_5 in
let fr3 = fmul_r5 #4 fr2 fr fr_5 in
let out = fmul_r4_normalize50 acc fr fr2 fr3 fr4 in
let v2 = fmul_r4_normalize51 out in
let res = carry_full_felem5 v2 in
carry_full_felem5_lemma v2
#pop-options
val load_felem5_lemma:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w ->
Lemma
(let f = load_felem5 #w lo hi in
felem_fits5 f (1, 1, 1, 1, 1) /\
felem_less5 f (pow2 128) /\
feval5 f == createi #Vec.pfelem w
(fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]))
let load_felem5_lemma #w lo hi =
let f = load_felem5 #w lo hi in
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 128 < Vec.prime);
let res = createi #Vec.pfelem w
(fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in
match w with
| 1 ->
load_felem5_lemma_i #w lo hi 0;
eq_intro (feval5 f) res
| 2 ->
load_felem5_lemma_i #w lo hi 0;
load_felem5_lemma_i #w lo hi 1;
eq_intro (feval5 f) res
| 4 ->
load_felem5_lemma_i #w lo hi 0;
load_felem5_lemma_i #w lo hi 1;
load_felem5_lemma_i #w lo hi 2;
load_felem5_lemma_i #w lo hi 3;
eq_intro (feval5 f) res
val load_felem5_4_interleave: lo:uint64xN 4 -> hi:uint64xN 4 -> Lemma
(let m0 = vec_interleave_low_n 2 lo hi in
let m1 = vec_interleave_high_n 2 lo hi in
let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in
let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in
let m4 = vec_interleave_high m0 m1 in
let t0 = vec_interleave_low m0 m1 in
let t3 = vec_interleave_low m2 m3 in
vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3] /\
vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2] /\
t3 == vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul))
let load_felem5_4_interleave lo hi =
let m0 = vec_interleave_low_n 2 lo hi in
vec_interleave_low_n_lemma_uint64_4_2 lo hi;
//assert (vec_v m0 == create4 (vec_v lo).[0] (vec_v lo).[1] (vec_v hi).[0] (vec_v hi).[1]);
let m1 = vec_interleave_high_n 2 lo hi in
vec_interleave_high_n_lemma_uint64_4_2 lo hi;
//assert (vec_v m1 == create4 (vec_v lo).[2] (vec_v lo).[3] (vec_v hi).[2] (vec_v hi).[3]);
let m4 = vec_interleave_high m0 m1 in
vec_interleave_high_lemma_uint64_4 m0 m1;
//assert (vec_v m4 == create4 (vec_v m0).[1] (vec_v m1).[1] (vec_v m0).[3] (vec_v m1).[3]);
assert (vec_v m4 == create4 (vec_v lo).[1] (vec_v lo).[3] (vec_v hi).[1] (vec_v hi).[3]);
let t0 = vec_interleave_low m0 m1 in
vec_interleave_low_lemma_uint64_4 m0 m1;
//assert (vec_v t0 == create4 (vec_v m0).[0] (vec_v m1).[0] (vec_v m0).[2] (vec_v m1).[2]);
assert (vec_v t0 == create4 (vec_v lo).[0] (vec_v lo).[2] (vec_v hi).[0] (vec_v hi).[2]);
let m2 = cast U64 4 (vec_shift_right (cast U128 2 m0) 48ul) in
vec_shift_right_uint128_small2 m0 48ul;
assert ((vec_v m2).[0] == (((vec_v lo).[0] >>. 48ul) |. ((vec_v lo).[1] <<. 16ul)));
assert ((vec_v m2).[2] == (((vec_v hi).[0] >>. 48ul) |. ((vec_v hi).[1] <<. 16ul)));
let m3 = cast U64 4 (vec_shift_right (cast U128 2 m1) 48ul) in
vec_shift_right_uint128_small2 m1 48ul;
assert ((vec_v m3).[0] == (((vec_v lo).[2] >>. 48ul) |. ((vec_v lo).[3] <<. 16ul)));
assert ((vec_v m3).[2] == (((vec_v hi).[2] >>. 48ul) |. ((vec_v hi).[3] <<. 16ul)));
let t3 = vec_interleave_low m2 m3 in
vec_interleave_low_lemma_uint64_4 m2 m3;
eq_intro (vec_v t3) (vec_v (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul)));
vecv_extensionality t3 (vec_or (vec_shift_right t0 48ul) (vec_shift_left m4 16ul))
noextract
val load_felem5_4_compact: lo:uint64xN 4 -> hi:uint64xN 4 -> felem5 4
let load_felem5_4_compact lo hi =
let mask26 = mask26 4 in
let t3 = vec_or (vec_shift_right lo 48ul) (vec_shift_left hi 16ul) in
let o0 = vec_and lo mask26 in
let o1 = vec_and (vec_shift_right lo 26ul) mask26 in
let o2 = vec_and (vec_shift_right t3 4ul) mask26 in
let o3 = vec_and (vec_shift_right t3 30ul) mask26 in
let o4 = vec_shift_right hi 40ul in
(o0, o1, o2, o3, o4)
val load_felem5_4_compact_lemma_i: lo:uint64xN 4 -> hi:uint64xN 4 -> i:nat{i < 4} ->
Lemma
(let f = as_tup64_i (load_felem5_4_compact lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % Vec.prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_4_compact_lemma_i lo hi i =
assert (as_tup64_i (load_felem5_4_compact lo hi) i == load_tup64_4_compact (vec_v lo).[i] (vec_v hi).[i]);
load_tup64_4_compact_lemma (vec_v lo).[i] (vec_v hi).[i]
val load_felem5_4_lemma: lo:uint64xN 4 -> hi:uint64xN 4 ->
Lemma
(let f = load_felem5_4_compact lo hi in
felem_fits5 f (1, 1, 1, 1, 1) /\
felem_less5 f (pow2 128) /\
feval5 f == createi #Vec.pfelem 4 (fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]))
let load_felem5_4_lemma lo hi =
let f = load_felem5_4_compact lo hi in
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 128 < Vec.prime);
let res = createi #Vec.pfelem 4
(fun i -> (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) in
load_felem5_4_compact_lemma_i lo hi 0;
load_felem5_4_compact_lemma_i lo hi 1;
load_felem5_4_compact_lemma_i lo hi 2;
load_felem5_4_compact_lemma_i lo hi 3;
eq_intro (feval5 f) res
val load_felem5_le: b:lseq uint8 64 -> Lemma
(let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in
let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in
let f = load_felem5_4 lo0 hi0 in
felem_fits5 f (1, 1, 1, 1, 1) /\
felem_less5 f (pow2 128) /\
feval5 f == Vec.load_elem4 b)
let load_felem5_le b =
let lo0 = vec_from_bytes_le U64 4 (sub b 0 32) in
let hi0 = vec_from_bytes_le U64 4 (sub b 32 32) in
let lo1 = vec_interleave_low_n 2 lo0 hi0 in
let hi1 = vec_interleave_high_n 2 lo0 hi0 in
let lo = vec_interleave_low lo1 hi1 in
let hi = vec_interleave_high lo1 hi1 in
let out = load_felem5_4_compact lo hi in
load_felem5_4_interleave lo0 hi0;
assert (out == load_felem5_4 lo0 hi0);
load_felem5_4_lemma lo hi;
Hacl.Impl.Poly1305.Lemmas.uints_from_bytes_le_lemma64_4 b;
eq_intro (feval5 out) (Vec.load_elem4 b)
val load_acc5_2_lemma:
f:felem5 2{felem_fits5 f (2, 2, 2, 2, 2)}
-> e:felem5 2{felem_fits5 e (1, 1, 1, 1, 1)} ->
Lemma
(let res = load_acc5_2 f e in
felem_fits5 res (3, 3, 3, 3, 3) /\
feval5 res == Vec.fadd (create2 (feval5 f).[0] 0) (feval5 e))
[SMTPat (load_acc5_2 f e)]
let load_acc5_2_lemma f e =
let (f0, f1, f2, f3, f4) = f in
let r0 = vec_set f0 1ul (u64 0) in
let r1 = vec_set f1 1ul (u64 0) in
let r2 = vec_set f2 1ul (u64 0) in
let r3 = vec_set f3 1ul (u64 0) in
let r4 = vec_set f4 1ul (u64 0) in
let r = (r0, r1, r2, r3, r4) in
//assert ((feval5 r).[0] == (feval5 f).[0]);
assert ((feval5 r).[1] == 0);
eq_intro (feval5 r) (create2 (feval5 f).[0] 0)
val load_acc5_4_lemma:
f:felem5 4{felem_fits5 f (2, 2, 2, 2, 2)}
-> e:felem5 4{felem_fits5 e (1, 1, 1, 1, 1)} ->
Lemma
(let res = load_acc5_4 f e in
felem_fits5 res (3, 3, 3, 3, 3) /\
feval5 res == Vec.fadd (create4 (feval5 f).[0] 0 0 0) (feval5 e))
[SMTPat (load_acc5_4 f e)]
let load_acc5_4_lemma f e =
let (f0, f1, f2, f3, f4) = f in
let (r0, r1, r2, r3, r4) = (zero 4, zero 4, zero 4, zero 4, zero 4) in
let r = (r0, r1, r2, r3, r4) in
assert ((feval5 r).[1] == 0);
assert ((feval5 r).[2] == 0);
assert ((feval5 r).[3] == 0);
let r0 = vec_set r0 0ul (vec_get f0 0ul) in
let r1 = vec_set r1 0ul (vec_get f1 0ul) in
let r2 = vec_set r2 0ul (vec_get f2 0ul) in
let r3 = vec_set r3 0ul (vec_get f3 0ul) in
let r4 = vec_set r4 0ul (vec_get f4 0ul) in
let r = (r0, r1, r2, r3, r4) in
assert ((feval5 r).[0] == (feval5 f).[0]);
assert ((feval5 r).[1] == 0);
assert ((feval5 r).[2] == 0);
assert ((feval5 r).[3] == 0);
eq_intro (feval5 r) (create4 (feval5 f).[0] 0 0 0)
val store_felem5_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (1, 1, 1, 1, 1)} ->
Lemma
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)
[SMTPat (store_felem5 f)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val store_felem5_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (1, 1, 1, 1, 1)} ->
Lemma
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)
[SMTPat (store_felem5 f)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.store_felem5_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (1, 1, 1, 1, 1)}
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Poly1305.Field32xN.store_felem5 f in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ lo hi = _ in
Lib.IntTypes.v hi * Prims.pow2 64 + Lib.IntTypes.v lo ==
(Hacl.Spec.Poly1305.Field32xN.fas_nat5 f).[ 0 ] % Prims.pow2 128)
<:
Type0)) [SMTPat (Hacl.Spec.Poly1305.Field32xN.store_felem5 f)] | {
"end_col": 25,
"end_line": 827,
"start_col": 2,
"start_line": 827
} |
FStar.Pervasives.Lemma | val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime | val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i = | false | null | true | assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[ i ] == (as_nat5 (transpose f).[ i ]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[ i ]) Vec.prime | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_less5",
"Prims.pow2",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Math.Lemmas.modulo_lemma",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Hacl.Spec.Poly1305.Field32xN.transpose",
"Hacl.Spec.Poly1305.Vec.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Poly1305.Vec.pfelem",
"Hacl.Spec.Poly1305.Field32xN.feval5",
"Prims.op_Modulus",
"FStar.Pervasives.assert_norm"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i]) | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.lemma_feval_is_fas_nat_i | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_less5 f (Prims.pow2 128)} ->
i: Lib.IntTypes.size_nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
(Hacl.Spec.Poly1305.Field32xN.feval5 f).[ i ] ==
(Hacl.Spec.Poly1305.Field32xN.fas_nat5 f).[ i ]) | {
"end_col": 70,
"end_line": 27,
"start_col": 2,
"start_line": 25
} |
FStar.Pervasives.Lemma | val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) | val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 = | false | null | true | let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2)) | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Poly1305.Vec.pfelem",
"Hacl.Spec.Poly1305.Field32xN.feval5",
"Lib.Sequence.map2",
"Hacl.Spec.Poly1305.Vec.pfadd",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Poly1305.Field32xN.fadd5",
"Hacl.Poly1305.Field32xN.Lemmas0.fadd5_eval_lemma_i"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.fadd5_eval_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f1 (2, 2, 2, 2, 2)} ->
f2:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f2 (1, 1, 1, 1, 1)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.feval5 (Hacl.Spec.Poly1305.Field32xN.fadd5 f1 f2) ==
Lib.Sequence.map2 Hacl.Spec.Poly1305.Vec.pfadd
(Hacl.Spec.Poly1305.Field32xN.feval5 f1)
(Hacl.Spec.Poly1305.Field32xN.feval5 f2))
[SMTPat (Hacl.Spec.Poly1305.Field32xN.fadd5 f1 f2)] | {
"end_col": 62,
"end_line": 100,
"start_col": 31,
"start_line": 97
} |
FStar.Pervasives.Lemma | val reduce_felem5_eval_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} ->
Lemma
(felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\
(feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0])
[SMTPat (reduce_felem5 f)] | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas1",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN.Lemmas0",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let reduce_felem5_eval_lemma #w f =
carry_full_felem5_eval_lemma f;
carry_full_felem5_fits_lemma f;
let f = carry_full_felem5 f in
carry_reduce_felem5_lemma #w f;
subtract_p5_felem5_lemma #w (carry_full_felem5 f) | val reduce_felem5_eval_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} ->
Lemma
(felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\
(feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0])
[SMTPat (reduce_felem5 f)]
let reduce_felem5_eval_lemma #w f = | false | null | true | carry_full_felem5_eval_lemma f;
carry_full_felem5_fits_lemma f;
let f = carry_full_felem5 f in
carry_reduce_felem5_lemma #w f;
subtract_p5_felem5_lemma #w (carry_full_felem5 f) | {
"checked_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas1.fst.checked",
"Hacl.Poly1305.Field32xN.Lemmas0.fst.checked",
"Hacl.Impl.Poly1305.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Poly1305.Field32xN.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Hacl.Poly1305.Field32xN.Lemmas1.subtract_p5_felem5_lemma",
"Hacl.Spec.Poly1305.Field32xN.carry_full_felem5",
"Prims.unit",
"Hacl.Poly1305.Field32xN.Lemmas1.carry_reduce_felem5_lemma",
"Hacl.Poly1305.Field32xN.Lemmas1.carry_full_felem5_fits_lemma",
"Hacl.Poly1305.Field32xN.Lemmas1.carry_full_felem5_eval_lemma"
] | [] | module Hacl.Spec.Poly1305.Field32xN.Lemmas
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open Hacl.Spec.Poly1305.Field32xN
open Hacl.Poly1305.Field32xN.Lemmas0
open Hacl.Poly1305.Field32xN.Lemmas1
open Hacl.Poly1305.Field32xN.Lemmas2
module Vec = Hacl.Spec.Poly1305.Vec
#set-options "--z3rlimit 100 --max_fuel 0 --initial_ifuel 1 --max_ifuel 1 --using_facts_from '* -FStar.Seq'"
val lemma_feval_is_fas_nat_i:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)}
-> i:size_nat{i < w} ->
Lemma ((feval5 f).[i] == (fas_nat5 f).[i])
let lemma_feval_is_fas_nat_i #w f i =
assert_norm (pow2 128 < Vec.prime);
assert ((feval5 f).[i] == (as_nat5 (transpose f).[i]) % Vec.prime);
FStar.Math.Lemmas.modulo_lemma (as_nat5 (transpose f).[i]) Vec.prime
val lemma_feval_is_fas_nat:
#w:lanes
-> f:felem5 w{felem_less5 f (pow2 128)} ->
Lemma (forall (i:nat). i < w ==> (fas_nat5 f).[i] == (feval5 f).[i])
let lemma_feval_is_fas_nat #w f =
FStar.Classical.forall_intro (lemma_feval_is_fas_nat_i #w f)
val precomp_r5_fits_lemma:
#w:lanes
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (5, 5, 5, 5, 5))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_fits_lemma2:
#w:lanes
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)} ->
Lemma (felem_fits5 (precomp_r5 #w r) (10, 10, 10, 10, 10))
[SMTPat (precomp_r5 #w r)]
let precomp_r5_fits_lemma2 #w r =
FStar.Classical.forall_intro (precomp_r5_as_tup64 #w r)
val precomp_r5_zeros: w:lanes -> Lemma
(let r = (zero w, zero w, zero w, zero w, zero w) in
precomp_r5 r == (zero w, zero w, zero w, zero w, zero w))
let precomp_r5_zeros w =
let r = (zero w, zero w, zero w, zero w, zero w) in
let (r0, r1, r2, r3, r4) = precomp_r5 r in
let aux (i:nat{i < w}) : Lemma ((vec_v (vec_smul_mod (zero w) (u64 5))).[i] == u64 0) = () in
Classical.forall_intro aux;
eq_intro (vec_v (vec_smul_mod (zero w) (u64 5))) (vec_v (zero w));
vecv_extensionality (vec_smul_mod (zero w) (u64 5)) (zero w)
val fadd5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (felem_fits5 (fadd5 f1 f2) (3,3,3,3,3))
[SMTPat (fadd5 f1 f2)]
let fadd5_fits_lemma #w f1 f2 =
let (f10, f11, f12, f13, f14) = f1 in
let (f20, f21, f22, f23, f24) = f2 in
let o = fadd5 f1 f2 in
vec_add_mod_lemma f10 f20;
vec_add_mod_lemma f11 f21;
vec_add_mod_lemma f12 f22;
vec_add_mod_lemma f13 f23;
vec_add_mod_lemma f14 f24
val fadd5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (2,2,2,2,2)}
-> f2:felem5 w{felem_fits5 f2 (1,1,1,1,1)} ->
Lemma (feval5 (fadd5 f1 f2) == map2 Vec.pfadd (feval5 f1) (feval5 f2))
[SMTPat (fadd5 f1 f2)]
let fadd5_eval_lemma #w f1 f2 =
let o = fadd5 f1 f2 in
FStar.Classical.forall_intro (fadd5_eval_lemma_i f1 f2);
eq_intro (feval5 o) (map2 Vec.pfadd (feval5 f1) (feval5 f2))
val mul_felem5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_wide_fits5 (mul_felem5 #w f1 r r5) (126, 102, 78, 54, 30))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_fits_lemma #w f1 r r5 =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34)
val mul_felem5_eval_lemma_i:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r}
-> i:nat{i < w} ->
Lemma ((feval5 (mul_felem5 #w f1 r r5)).[i] == (feval5 f1).[i] `Vec.pfmul` (feval5 r).[i])
let mul_felem5_eval_lemma_i #w f1 r r5 i =
let (r0, r1, r2, r3, r4) = r in
let (f10, f11, f12, f13, f14) = f1 in
let (r50, r51, r52, r53, r54) = r5 in
let (a0,a1,a2,a3,a4) = smul_felem5 #w f10 (r0,r1,r2,r3,r4) in
smul_felem5_eval_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
smul_felem5_fits_lemma #w #3 #(2,2,2,2,2) f10 (r0,r1,r2,r3,r4);
assert ((fas_nat5 (a0,a1,a2,a3,a4)).[i] == (uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i]);
let (a10,a11,a12,a13,a14) = smul_add_felem5 #w f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4) in
smul_add_felem5_eval_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
smul_add_felem5_fits_lemma #w #3 #(10,2,2,2,2) #(6,6,6,6,6) f11 (r54,r0,r1,r2,r3) (a0,a1,a2,a3,a4);
assert ((fas_nat5 (a10,a11,a12,a13,a14)).[i] == (fas_nat5 (a0,a1,a2,a3,a4)).[i] + (uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i]);
let (a20,a21,a22,a23,a24) = smul_add_felem5 #w f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14) in
smul_add_felem5_eval_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
smul_add_felem5_fits_lemma #w #3 #(10,10,2,2,2) #(36,12,12,12,12) f12 (r53,r54,r0,r1,r2) (a10,a11,a12,a13,a14);
assert ((fas_nat5 (a20,a21,a22,a23,a24)).[i] == (fas_nat5 (a10,a11,a12,a13,a14)).[i] + (uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i]);
let (a30,a31,a32,a33,a34) = smul_add_felem5 #w f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,2,2) #(66,42,18,18,18) f13 (r52,r53,r54,r0,r1) (a20,a21,a22,a23,a24);
assert ((fas_nat5 (a30,a31,a32,a33,a34)).[i] == (fas_nat5 (a20,a21,a22,a23,a24)).[i] + (uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i]);
let (a40,a41,a42,a43,a44) = smul_add_felem5 #w f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34) in
smul_add_felem5_eval_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
smul_add_felem5_fits_lemma #w #3 #(10,10,10,10,2) #(96,72,48,24,24) f14 (r51,r52,r53,r54,r0) (a30,a31,a32,a33,a34);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] == (fas_nat5 (a30,a31,a32,a33,a34)).[i] + (uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
assert ((fas_nat5 (a40,a41,a42,a43,a44)).[i] ==
(uint64xN_v f10).[i] * (fas_nat5 (r0,r1,r2,r3,r4)).[i] +
(uint64xN_v f11).[i] * (fas_nat5 (r54,r0,r1,r2,r3)).[i] +
(uint64xN_v f12).[i] * (fas_nat5 (r53,r54,r0,r1,r2)).[i] +
(uint64xN_v f13).[i] * (fas_nat5 (r52,r53,r54,r0,r1)).[i] +
(uint64xN_v f14).[i] * (fas_nat5 (r51,r52,r53,r54,r0)).[i]);
mul_felem5_eval_as_tup64 #w f1 r r5 i;
mul_felem5_lemma (as_tup64_i f1 i) (as_tup64_i r i)
val mul_felem5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (mul_felem5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (mul_felem5 #w f1 r r5)]
let mul_felem5_eval_lemma #w f1 r r5 =
let tmp = map2 (Vec.pfmul) (feval5 f1) (feval5 r) in
FStar.Classical.forall_intro (mul_felem5_eval_lemma_i #w f1 r r5);
eq_intro (feval5 (mul_felem5 #w f1 r r5)) tmp
val fmul_r5_fits_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10)} ->
Lemma (felem_fits5 (fmul_r5 #w f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_fits_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_fits_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp
val fmul_r5_eval_lemma:
#w:lanes
-> f1:felem5 w{felem_fits5 f1 (3, 3, 3, 3, 3)}
-> r:felem5 w{felem_fits5 r (2, 2, 2, 2, 2)}
-> r5:felem5 w{felem_fits5 r5 (10, 10, 10, 10, 10) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fmul_r5 #w f1 r r5) == map2 (Vec.pfmul) (feval5 f1) (feval5 r))
[SMTPat (fmul_r5 #w f1 r r5)]
let fmul_r5_eval_lemma #w f1 r r5 =
let tmp = mul_felem5 f1 r r5 in
mul_felem5_eval_lemma #w f1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp
val fadd_mul_r5_fits_lemma:
#w:lanes
-> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)}
-> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)}
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)}
-> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5)} ->
Lemma (felem_fits5 (fadd_mul_r5 acc f1 r r5) (1, 2, 1, 1, 2))
[SMTPat (fadd_mul_r5 acc f1 r r5)]
let fadd_mul_r5_fits_lemma #w acc f1 r r5 =
let acc1 = fadd5 acc f1 in
fadd5_fits_lemma #w acc f1;
let tmp = mul_felem5 acc1 r r5 in
mul_felem5_fits_lemma #w acc1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_fits_lemma #w tmp
val fadd_mul_r5_eval_lemma:
#w:lanes
-> acc:felem5 w{felem_fits5 acc (2, 2, 2, 2, 2)}
-> f1:felem5 w{felem_fits5 f1 (1, 1, 1, 1, 1)}
-> r:felem5 w{felem_fits5 r (1, 1, 1, 1, 1)}
-> r5:felem5 w{felem_fits5 r5 (5, 5, 5, 5, 5) /\ r5 == precomp_r5 r} ->
Lemma (feval5 (fadd_mul_r5 acc f1 r r5) ==
map2 (Vec.pfmul) (map2 (Vec.pfadd) (feval5 acc) (feval5 f1)) (feval5 r))
[SMTPat (fadd_mul_r5 acc f1 r r5)]
let fadd_mul_r5_eval_lemma #w acc f1 r r5 =
let acc1 = fadd5 acc f1 in
fadd5_eval_lemma #w acc f1;
let tmp = mul_felem5 acc1 r r5 in
mul_felem5_eval_lemma #w acc1 r r5;
let res = carry_wide_felem5 tmp in
carry_wide_felem5_eval_lemma #w tmp
val reduce_felem5_eval_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} ->
Lemma
(felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\
(feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0])
[SMTPat (reduce_felem5 f)] | false | false | Hacl.Spec.Poly1305.Field32xN.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reduce_felem5_eval_lemma:
#w:lanes
-> f:felem5 w{felem_fits5 f (2, 2, 2, 2, 2)} ->
Lemma
(felem_fits5 (reduce_felem5 f) (1, 1, 1, 1, 1) /\
(feval5 f).[0] == (fas_nat5 (reduce_felem5 f)).[0])
[SMTPat (reduce_felem5 f)] | [] | Hacl.Spec.Poly1305.Field32xN.Lemmas.reduce_felem5_eval_lemma | {
"file_name": "code/poly1305/Hacl.Spec.Poly1305.Field32xN.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Poly1305.Field32xN.felem5 w
{Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (2, 2, 2, 2, 2)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Poly1305.Field32xN.felem_fits5 (Hacl.Spec.Poly1305.Field32xN.reduce_felem5 f)
(1, 1, 1, 1, 1) /\
(Hacl.Spec.Poly1305.Field32xN.feval5 f).[ 0 ] ==
(Hacl.Spec.Poly1305.Field32xN.fas_nat5 (Hacl.Spec.Poly1305.Field32xN.reduce_felem5 f)).[ 0 ]
) [SMTPat (Hacl.Spec.Poly1305.Field32xN.reduce_felem5 f)] | {
"end_col": 51,
"end_line": 266,
"start_col": 2,
"start_line": 262
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.